| import OAI.Computability.MeanPayoff.ArithmeticBounds |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace MeanPayoff.WorkStack.RegisterCompile |
|
|
| theorem signed_adds (a b : Bool) (xs ys out : List Bool) (bits : ℕ → Bool) : |
| RegisterBits.advance (program SignedAddition.program) bits |
| (lift SignedAddition.program out (SignedAddition.state .start (a::xs) (b::ys) [])) |
| (6*(2*max xs.length ys.length+5)) = |
| lift SignedAddition.program out (SignedAddition.stopped |
| ((SignedBits.add a b false xs ys).sign::(SignedBits.add a b false xs ys).digits) []) := by |
| rw [advance_six, SignedAddition.program_adds] |
| end MeanPayoff.WorkStack.RegisterCompile |
| namespace MeanPayoff.BinaryData |
|
|
| def boolData : Bool → Data |
| | false => .nil |
| | true => .pair .nil .nil |
|
|
| def listData : List Bool → Data |
| | [] => .nil |
| | b :: bs => .pair (boolData b) (listData bs) |
|
|
| def wordData (w : SignedBits.Word) : Data := listData (w.sign :: w.digits) |
|
|
| def consCode : Bool → List Bool |
| | false => [true, false] |
| | true => [true, true, false, false] |
|
|
| @[simp] theorem encode_list_nil : encode (listData []) = [false] := rfl |
| @[simp] theorem encode_list_cons (b : Bool) (bs : List Bool) : |
| encode (listData (b :: bs)) = consCode b ++ encode (listData bs) := by cases b <;> rfl |
|
|
| @[simp] theorem consCode_length_le (b : Bool) : (consCode b).length ≤ 4 := by cases b <;> decide |
|
|
| def feedCost : List Bool → ℕ |
| | [] => 0 |
| | b :: bs => (consCode b).length + 1 + feedCost bs |
|
|
| @[simp] theorem feedCost_append (a b : List Bool) : feedCost (a ++ b) = feedCost a + feedCost b := by |
| induction a with |
| | nil => simp [feedCost] |
| | cons x xs ih => simp only [List.cons_append, feedCost, ih]; omega |
|
|
| @[simp] theorem feedCost_reverse (a : List Bool) : feedCost a.reverse = feedCost a := by |
| induction a with |
| | nil => rfl |
| | cons b bs ih => simp only [List.reverse_cons, feedCost_append, ih, feedCost]; omega |
|
|
| theorem feedCost_le (a : List Bool) : feedCost a ≤ 5*a.length := by |
| induction a with |
| | nil => rfl |
| | cons b bs ih => have := consCode_length_le b; simp only [feedCost, List.length_cons]; omega |
|
|
| theorem encode_list_length_le (a : List Bool) : (encode (listData a)).length ≤ 4*a.length+1 := by |
| induction a with |
| | nil => simp |
| | cons b bs ih => |
| simp only [encode_list_cons, List.length_append, List.length_cons] |
| have := consCode_length_le b; omega |
|
|
| namespace Unbox |
| open RegisterBits |
| open BinaryStack (applyOp) |
| open Take (config_ext advance_front advance_add) |
|
|
| inductive Label where |
| | read | bit | skip0 | skip1 | push (b : Bool) | restore | put (b : Bool) |
| 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 q |
|
|
| noncomputable def program : Program 3 where |
| states := Fintype.card Label |
| start := enc .read |
| read q := match equiv.symm q with |
| | .read | .bit | .skip0 | .skip1 => 0 |
| | .push _ | .restore => 2 |
| | .put _ => 1 |
| transition q top _ := match equiv.symm q with |
| | .read => top.map fun b => ⟨enc (if b then .bit else .restore), .pop, none⟩ |
| | .bit => top.map fun b => ⟨enc (if b then .skip0 else .push false), .pop, none⟩ |
| | .skip0 => some ⟨enc .skip1, .pop, none⟩ |
| | .skip1 => some ⟨enc (.push true), .pop, none⟩ |
| | .push b => some ⟨enc .read, .push b, none⟩ |
| | .restore => top.map fun b => ⟨enc (.put b), .pop, none⟩ |
| | .put b => some ⟨enc .restore, .push b, none⟩ |
|
|
| noncomputable def cfg (q : Label) (xs ys zs out : List Bool) : Config program := |
| ⟨some (enc q), ![xs,ys,zs], out⟩ |
| def stopped (xs ys out : List Bool) : Config program := ⟨none, ![xs,ys,[]], out⟩ |
|
|
| @[simp] theorem read_nil (xs ys zs out : List Bool) (b : Bool) : |
| RegisterBits.step program (cfg .read (false::xs) ys zs out) b = cfg .restore xs ys zs out := by |
| apply config_ext <;> simp [RegisterBits.step, cfg, program, applyOp] |
| funext i; fin_cases i <;> rfl |
|
|
| theorem feed_one (b : Bool) (xs ys zs out : List Bool) (bits : ℕ → Bool) : |
| advance program bits (cfg .read (consCode b ++ xs) ys zs out) |
| ((consCode b).length + 1) = cfg .read xs ys (b::zs) out := by |
| cases b <;> |
| apply config_ext <;> |
| simp [advance, RegisterBits.step, cfg, program, consCode, applyOp] |
| all_goals funext i; fin_cases i <;> rfl |
|
|
| theorem feeds (bs xs ys zs out : List Bool) (bits : ℕ → Bool) : |
| advance program bits (cfg .read (encode (listData bs) ++ xs) ys zs out) |
| (feedCost bs) = cfg .read (false::xs) ys (bs.reverse ++ zs) out := by |
| induction bs generalizing zs bits with |
| | nil => rfl |
| | cons b bs ih => |
| simp only [encode_list_cons, List.append_assoc, feedCost] |
| rw [advance_add, feed_one, ih] |
| simp [List.reverse_cons, List.append_assoc] |
|
|
| @[simp] theorem restore_read (b : Bool) (xs ys zs out : List Bool) (coin : Bool) : |
| RegisterBits.step program (cfg .restore xs ys (b::zs) out) coin = cfg (.put b) xs ys zs out := by |
| apply config_ext <;> simp [RegisterBits.step, cfg, program, applyOp] |
| funext i; fin_cases i <;> rfl |
| @[simp] theorem restore_put (b : Bool) (xs ys zs out : List Bool) (coin : Bool) : |
| RegisterBits.step program (cfg (.put b) xs ys zs out) coin = cfg .restore xs (b::ys) zs out := by |
| apply config_ext <;> simp [RegisterBits.step, cfg, program, applyOp] |
| funext i; fin_cases i <;> rfl |
| @[simp] theorem restore_done (xs ys out : List Bool) (coin : Bool) : |
| RegisterBits.step program (cfg .restore xs ys [] out) coin = stopped xs ys out := by |
| simp [RegisterBits.step, cfg, program, stopped] |
|
|
| theorem restores (zs xs ys out : List Bool) (bits : ℕ → Bool) : |
| advance program bits (cfg .restore xs ys zs out) (2*zs.length+1) = |
| stopped xs (zs.reverse ++ ys) out := by |
| induction zs generalizing ys bits with |
| | nil => simp [advance] |
| | cons b zs ih => |
| rw [show 2*(b::zs).length+1 = (2*zs.length+1+1)+1 by simp; omega, |
| Take.advance_front, restore_read, Take.advance_front, restore_put, ih] |
| simp [List.reverse_cons, List.append_assoc] |
|
|
| theorem read_nil_advance (xs ys zs out : List Bool) (bits : ℕ → Bool) : |
| advance program bits (cfg .read (false::xs) ys zs out) 1 = cfg .restore xs ys zs out := by |
| simp only [advance, read_nil] |
|
|
| theorem unboxes (bs xs ys out : List Bool) (bits : ℕ → Bool) : |
| advance program bits (cfg .read (encode (listData bs) ++ xs) ys [] out) |
| (feedCost bs+1+(2*bs.length+1)) = stopped xs (bs++ys) out := by |
| rw [advance_add _ _ _ (feedCost bs+1) (2*bs.length+1), |
| advance_add _ _ _ (feedCost bs) 1, feeds] |
| simp only [List.append_nil, read_nil_advance] |
| rw [show bs.length = bs.reverse.length by simp, restores] |
| simp |
|
|
| theorem unboxes_bound (bs : List Bool) : feedCost bs+1+(2*bs.length+1) ≤ 7*bs.length+2 := by |
| have := feedCost_le bs; omega |
|
|
| end Unbox |
| end MeanPayoff.BinaryData |
| namespace MeanPayoff.BinaryData.Box |
| open RegisterBits |
| open BinaryStack (applyOp) |
| open Take (config_ext advance_add) |
|
|
| inductive Label where |
| | reverse | revPut (b : Bool) | init | feed | zero | one0 | one1 | one2 | last |
| 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 q |
|
|
| noncomputable def program : Program 3 where |
| states := Fintype.card Label |
| start := enc .reverse |
| read q := match equiv.symm q with |
| | .reverse => 0 |
| | .revPut _ | .feed => 2 |
| | _ => 1 |
| transition q top _ := match equiv.symm q with |
| | .reverse => some (match top with |
| | none => ⟨enc .init, .keep, none⟩ |
| | some b => ⟨enc (.revPut b), .pop, none⟩) |
| | .revPut b => some ⟨enc .reverse, .push b, none⟩ |
| | .init => some ⟨enc .feed, .push false, none⟩ |
| | .feed => top.map fun b => ⟨enc (if b then .one0 else .zero), .pop, none⟩ |
| | .zero => some ⟨enc .last, .push false, none⟩ |
| | .one0 => some ⟨enc .one1, .push false, none⟩ |
| | .one1 => some ⟨enc .one2, .push false, none⟩ |
| | .one2 => some ⟨enc .last, .push true, none⟩ |
| | .last => some ⟨enc .feed, .push true, none⟩ |
|
|
| noncomputable def cfg (q : Label) (xs ys zs out : List Bool) : Config program := |
| ⟨some (enc q), ![xs,ys,zs], out⟩ |
| def stopped (ys out : List Bool) : Config program := ⟨none, ![[],ys,[]], out⟩ |
|
|
| @[simp] theorem reverse_read (b : Bool) (xs ys zs out : List Bool) (coin : Bool) : |
| RegisterBits.step program (cfg .reverse (b::xs) ys zs out) coin = cfg (.revPut b) xs ys zs out := by |
| apply config_ext <;> simp [RegisterBits.step, cfg, program, applyOp] |
| funext i; fin_cases i <;> rfl |
| @[simp] theorem reverse_put (b : Bool) (xs ys zs out : List Bool) (coin : Bool) : |
| RegisterBits.step program (cfg (.revPut b) xs ys zs out) coin = cfg .reverse xs ys (b::zs) out := by |
| apply config_ext <;> simp [RegisterBits.step, cfg, program, applyOp] |
| funext i; fin_cases i <;> rfl |
|
|
| theorem reverses (bs ys zs out : List Bool) (bits : ℕ → Bool) : |
| advance program bits (cfg .reverse bs ys zs out) (2*bs.length) = |
| cfg .reverse [] ys (bs.reverse++zs) out := by |
| induction bs generalizing zs bits with |
| | nil => rfl |
| | cons b bs ih => |
| rw [show 2*(b::bs).length = (2*bs.length+1)+1 by simp; omega, |
| Take.advance_front, reverse_read, Take.advance_front, reverse_put, ih] |
| simp [List.reverse_cons, List.append_assoc] |
|
|
| theorem initializes (ys zs out : List Bool) (bits : ℕ → Bool) : |
| advance program bits (cfg .reverse [] ys zs out) 2 = cfg .feed [] (false::ys) zs out := by |
| apply config_ext <;> simp [advance, RegisterBits.step, cfg, program, applyOp] |
| funext i; fin_cases i <;> rfl |
|
|
| theorem feed_one (b : Bool) (xs ys zs out : List Bool) (bits : ℕ → Bool) : |
| advance program bits (cfg .feed xs ys (b::zs) out) ((consCode b).length+1) = |
| cfg .feed xs (consCode b++ys) zs out := by |
| cases b <;> |
| apply config_ext <;> |
| simp [advance, RegisterBits.step, cfg, program, consCode, applyOp] |
| all_goals funext i; fin_cases i <;> rfl |
|
|
| theorem feeds (bs acc xs ys out : List Bool) (bits : ℕ → Bool) : |
| advance program bits (cfg .feed xs (encode (listData acc)++ys) bs out) (feedCost bs) = |
| cfg .feed xs (encode (listData (bs.reverse++acc))++ys) [] out := by |
| induction bs generalizing acc bits with |
| | nil => rfl |
| | cons b bs ih => |
| rw [feedCost, advance_add, feed_one] |
| rw [← List.append_assoc, ← encode_list_cons, ih] |
| simp [List.reverse_cons, List.append_assoc] |
|
|
| @[simp] theorem feed_done (ys out : List Bool) (coin : Bool) : |
| RegisterBits.step program (cfg .feed [] ys [] out) coin = stopped ys out := by |
| simp [RegisterBits.step, cfg, program, stopped] |
|
|
| theorem boxes (bs ys out : List Bool) (bits : ℕ → Bool) : |
| advance program bits (cfg .reverse bs ys [] out) |
| (2*bs.length+2+feedCost bs+1) = stopped (encode (listData bs)++ys) out := by |
| rw [advance_add _ _ _ (2*bs.length+2+feedCost bs) 1, |
| advance_add _ _ _ (2*bs.length+2) (feedCost bs), |
| advance_add _ _ _ (2*bs.length) 2, reverses] |
| simp only [List.append_nil] |
| rw [initializes] |
| change advance _ _ (advance _ _ (cfg .feed [] (encode (listData [])++ys) bs.reverse out) _) 1 = _ |
| rw [← feedCost_reverse bs, feeds] |
| simp [advance] |
|
|
| theorem boxes_bound (bs : List Bool) : 2*bs.length+2+feedCost bs+1 ≤ 7*bs.length+3 := by |
| have := feedCost_le bs; omega |
|
|
| end MeanPayoff.BinaryData.Box |
| namespace MeanPayoff.RegisterBits.Flow |
| open BinaryData.Take (advance_add) |
|
|
| theorem hop {K : ℕ} (P : Program K) (p q : Fin P.nodes) (s t : Fin K → List Bool) |
| (out : List Bool) (bits : ℕ → Bool) (N : ℕ) |
| (hm : advance (P.block p) bits ⟨some (P.block p).start, s, out⟩ N = ⟨none,t,out⟩) |
| (hn : ∀ top bit, P.next p top bit = some ⟨q, .keep, none⟩) : |
| ∃ d ≤ N+1, advance (compile P) bits (state P p s out) d = state P q t out := by |
| obtain ⟨d, hd, he⟩ := macro_runs P p s out bits N (by rw [hm]) |
| rw [hm] at he |
| refine ⟨d+1, by omega, ?_⟩ |
| simp only [advance, he, step_boundary, hn] |
| simp [BinaryStack.applyOp] |
|
|
| theorem finish {K : ℕ} (P : Program K) (p : Fin P.nodes) (s t : Fin K → List Bool) |
| (out : List Bool) (bits : ℕ → Bool) (N : ℕ) |
| (hm : advance (P.block p) bits ⟨some (P.block p).start, s, out⟩ N = ⟨none,t,out⟩) |
| (hn : ∀ top bit, P.next p top bit = none) : |
| ∃ d ≤ N+1, advance (compile P) bits (state P p s out) d = ⟨none,t,out⟩ := by |
| obtain ⟨d, hd, he⟩ := macro_runs P p s out bits N (by rw [hm]) |
| rw [hm] at he |
| refine ⟨d+1, by omega, ?_⟩ |
| simp only [advance, he, step_boundary, hn] |
| end MeanPayoff.RegisterBits.Flow |
| end |
|
|
| end OAI |
|
|
