| import OAI.Computability.Logspace.CounterPrograms |
|
|
| namespace OAI |
|
|
| /-! |
| Uniform numerical encodings and finite configuration graphs of randomized machines. |
|
|
| From OpenAI, *Exact Derandomization of Logarithmic Space: L = RL = BPL*. |
| -/ |
|
|
| set_option autoImplicit true |
|
|
| section |
|
|
| /-! Configuration reduction: numerical encoding. |
| Positions on work tapes represented relatively, by two binary stacks. Absolute |
| head positions are not observed by the machine; space bounds on the original |
| run give polynomial bounds on these relative encodings. |
| -/ |
| namespace ExactDerandomization.Base |
|
|
| abbrev front (n : ℕ) : Bool := decide (n%2=1) |
| def push (b : Bool) (n : ℕ) : ℕ := (if b then 1 else 0)+2*n |
|
|
| @[simp] lemma push_front (n : ℕ) : push (front n) (n/2) = n := by |
| simp only [push,front,decide_eq_true_eq]; split <;> omega |
| @[simp] lemma front_push (n : ℕ) (b : Bool) : front (push b n)=b := by |
| unfold push; cases b <;> simp [front,Nat.mul_comm 2] |
| @[simp] lemma div_push (n : ℕ) (b : Bool) : push b n/2=n := by |
| unfold push; split <;> omega |
|
|
| def bit : ℕ → ℕ → Bool |
| | a,0 => front a |
| | a,k+1 => bit (a/2) k |
|
|
| lemma bit_push (n k : ℕ) (b : Bool) : bit (push b n) (k+1)=bit n k := by rw [bit,div_push] |
| lemma bit_zero (k : ℕ) : bit 0 k=false := by induction k <;> simp_all [bit,front] |
|
|
| abbrev Zip := ℕ × ℕ |
|
|
| def Zip.act (a : Zip) (b : Bool) : Direction → Zip |
| | .stay => (a.1,push b (a.2/2)) |
| | .right => (push b a.1,a.2/2) |
| | .left => (a.1/2,push (front a.1) (push b (a.2/2))) |
|
|
| / |
| def Zipped (w : ℤ → Bool) (z : ℤ) (A : Zip) := |
| (∀ j : ℕ, bit A.1 j = w (z-1-j)) ∧ |
| (∀ j : ℕ, bit A.2 j = w (z+j)) |
|
|
| lemma Zipped.read {w z A} (h : Zipped w z A) : front A.2=w z := by simpa [bit] using h.2 0 |
|
|
| lemma upd_ne (w : ℤ → Bool) (b) (z z' y : ℤ) (e : z'≠z) (h : z'=y) : |
| Function.update w z b z' = w y := by simp [e,← h] |
|
|
| lemma Zipped.move {w z A} (h : Zipped w z A) (b : Bool) (d : Direction) : |
| Zipped (Function.update w z b) (d.move z) (A.act b d) := by |
| obtain ⟨hl,hr⟩ := h |
| cases d with |
| | stay => |
| dsimp [Zipped,Direction.move,Zip.act] |
| constructor |
| · intro j; rw [hl, upd_ne w b z _ _ (by omega) rfl] |
| · intro j |
| cases j with |
| | zero => simp [bit] |
| | succ j => rw [bit_push,← bit,hr,upd_ne w b z _ _ (by omega) rfl] |
| | right => |
| dsimp [Zipped,Direction.move,Zip.act] |
| constructor |
| · intro j |
| cases j with |
| | zero => simp [bit] |
| | succ j => |
| rw [bit_push,hl,upd_ne w b z _ (z-1-j) (by omega) (by omega)] |
| · intro j; rw [← bit,hr,upd_ne w b z _ _ (by omega) (show z+1+j=z+(↑(j+1):ℤ) by omega)] |
| | left => |
| dsimp [Zipped,Direction.move,Zip.act] |
| constructor |
| · intro j |
| rw [← bit,hl,upd_ne w b z _ _ (by omega) |
| (show z-1-1-j=z-1-↑(j+1) by omega)] |
| · intro j |
| cases j with |
| | zero => |
| have e := hl 0 |
| simp only [bit,Nat.cast_zero,sub_zero] at e |
| simp [bit,e] |
| | succ j => |
| cases j with |
| | zero => simp [bit] |
| | succ j => |
| rw [bit_push,bit_push, ← bit,hr,upd_ne w b z _ _ (by omega) |
| (show z-1+↑(j+1+1)=z+↑(j+1) by omega)] |
|
|
| lemma trunc_bits (m n : ℕ) (h : ∀ j, m≤j → bit n j=false) : n<2^m := by |
| induction m generalizing n with |
| | zero => |
|
|
| induction n using Nat.strong_induction_on with |
| | h n ih => |
| by_cases e : n=0 |
| · simp [e] |
| have he := ih (n/2) (by omega) (fun j _=> h (j+1) (by omega)) |
| have ht := h 0 (by omega) |
| simp [bit,front] at ht; simp at he; simp; omega |
| | succ m ih => |
| have he := ih (n/2) (fun j e=> h (j+1) (by omega)) |
| rw [pow_succ]; omega |
|
|
| lemma Zipped.bound {w z A} {s : ℕ} (h : Zipped w z A) |
| (hp : |z| ≤ (s:ℤ)) (hh : ∀ v, (s:ℤ) < |v| → w v=false) : |
| A.1<2^(2*s+1) ∧ A.2<2^(2*s+1) := by |
| rw [abs_le] at hp |
| constructor <;> apply trunc_bits <;> intro j hj |
| · rw [h.1, hh]; rw [lt_abs]; omega |
| · rw [h.2, hh]; rw [lt_abs]; omega |
|
|
| lemma Zip.unique {A A' : Zip} {b b' : Bool} {d : Direction} |
| (h : front A.2=front A'.2) |
| (e : A.act b d=A'.act b' d) : A=A' := by |
| have H : ∀ (z w : ℕ), front z=front w → z/2=w/2 → z=w := by |
| intro z w h h' |
| rw [← push_front z,h,h',push_front] |
| cases d <;> simp only [Zip.act,Prod.mk.injEq] at e |
| · |
| apply Prod.ext |
| · exact H _ _ (by simpa using congrArg front e.2) e.1 |
| · apply H _ _ h |
| simpa using congrArg (fun a : ℕ => a/2/2) e.2 |
| · exact Prod.ext e.1 (H _ _ h (by simpa using congrArg (fun a : ℕ=>a/2) e.2)) |
| · exact Prod.ext (by simpa using congrArg (fun a : ℕ=>a/2) e.1) (H _ _ h e.2) |
|
|
| end ExactDerandomization.Base |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Base |
|
|
| / |
| @[ext] structure R (w h : ℕ) where |
| tm : ℕ |
| st : ℕ |
| inp : Fin h → ℕ |
| tapes : Fin w → Zip |
|
|
| namespace R |
| variable {q w h : ℕ} (M : Machine q w h) |
|
|
| def state (A : R w h) (q : ℕ) : Fin (q+1) := ⟨A.st%(q+1), Nat.mod_lt _ (by omega)⟩ |
| def out (A : R w h) : Option Bool := M.output (A.state q) |
|
|
| def minput (x : Word) (i : ℕ) : Direction → ℕ |
| | .stay => i |
| | .left => i-1 |
| | .right => if i<x.length+1 then i+1 else i |
|
|
| lemma minput_fin (x : Word) (i : Fin (x.length+2)) (d : Direction) : |
| minput x i d = (d.moveInput i).val := by |
| cases d <;> simp [minput, Direction.moveInput] |
| split <;> omega |
|
|
| def action (A : R w h) (x : Word) (b : Bool) : Action q w h := |
| match A.out M with |
| | none => M.transition (A.state q) (fun i=> Counter.scan x (A.inp i)) |
| (fun i=> front (A.tapes i).2) b |
| | some _ => ⟨A.state q,fun i=> front (A.tapes i).2,fun _=>.stay,fun _=>.stay⟩ |
|
|
| def step (A : R w h) (x : Word) (b : Bool) : R w h := |
| let u := A.action M x b |
| { tm := A.tm+1 |
| st := u.nextState |
| inp := fun j=> minput x (A.inp j) (u.inputMove j) |
| tapes := fun k=> (A.tapes k).act (u.write k) (u.workMove k) } |
|
|
| def start : R w h := ⟨0,M.initialState.val,fun _=>0, fun _=>(0,0)⟩ |
|
|
| def runs (x : Word) (coins : CoinTape) : ℕ → R w h |
| | 0 => start M |
| | t+1 => step M (runs x coins t) x (coins t) |
|
|
| variable {M} |
| structure OK {n : ℕ} (t : ℕ) (A : R w h) (c : Configuration q w h n) : Prop where |
| tm : A.tm=t |
| st : A.st=c.state.val |
| inp (i : Fin h) : A.inp i = (c.inputPos i).val |
| tapes (k : Fin w) : Zipped (c.work k) (c.workPos k) (A.tapes k) |
|
|
| lemma OK.state {x : Word} {t A} {c : Configuration q w h x.length} (hc : OK t A c) : |
| A.state q = c.state := by ext; simp [R.state,hc.st,Nat.mod_eq_of_lt c.state.isLt] |
|
|
| lemma OK.next {x : Word} {t A} {c : Configuration q w h x.length} (hc : OK t A c) |
| (b : Bool) : |
| OK (t+1) (A.step M x b) (M.step x b c) := by |
| have hs : A.state q = c.state := hc.state (x:=x) |
| cases hb : M.output c.state with |
| | some v => |
| have he : M.step x b c=c := by simp [Machine.step,hb] |
| rw [he]; constructor |
| · simp [step,hc.tm] |
| · simp [step,action,out,hs,hb] |
| · simp [step,action,out,hs,hb,minput,hc.inp] |
| · intro k; simpa [step,action,out,hs,hb,Zip.act] using hc.tapes k |
| | none => |
| let u := M.transition c.state (fun i => readInput x (c.inputPos i)) |
| (fun k=> c.work k (c.workPos k)) b |
| have he : A.action M x b=u := by |
| have hh (k) := Zipped.read (hc.tapes k) |
| simp [R.action,out,u,hs,hb,hc.inp,hh] |
| constructor |
| · simp [step,hc.tm] |
| · simp [step,he,u,Machine.step,hb] |
| · intro i |
| simp only [step,he,hc.inp,minput_fin, Machine.step,hb]; rfl |
| · intro i |
| simp only [step,he,Machine.step,hb] |
| exact (hc.tapes i).move (u.write i) (u.workMove i) |
|
|
| variable (M) |
| lemma runs_OK (x : Word) (coins : CoinTape) (t) : |
| OK t (runs M x coins t) (M.run x coins t) := by |
| induction t with |
| | zero => |
| constructor |
| · rfl |
| · rfl |
| · intro i; rfl |
| · intro k; exact ⟨bit_zero,bit_zero⟩ |
| | succ t ih => exact ih.next _ |
|
|
| lemma runs_out (x : Word) (coins : CoinTape) (t) : |
| (runs M x coins t).out M = M.output (M.run x coins t).state := by |
| rw [out,(runs_OK M x coins t).state] |
|
|
| / |
| k,e time coefficient/exponent. -/ |
| def radix (q cs k e n : ℕ) : ℕ := q+2 + polynomialClock k e n + |
| (n+2) + 2*(2*(n+2))^(2*cs) |
|
|
| lemma radix_pos (q cs k e n : ℕ) : 0<radix q cs k e n := by unfold radix; positivity |
|
|
| def Small (A : R w h) (m : ℕ) := |
| A.tm < m ∧ A.st < m ∧ (∀ i, A.inp i < m) ∧ (∀ i, (A.tapes i).1 < m ∧ (A.tapes i).2 < m) |
|
|
| lemma runs_small (x : Word) (coins : CoinTape) {cs k e : ℕ} |
| (ht : ∀ t, M.spaceThrough x coins t ≤ cs * Nat.clog 2 (x.length+2)) |
| {t : ℕ} (he : t ≤ polynomialClock k e x.length) : |
| (runs M x coins t).Small (radix q cs k e x.length) := by |
| let n := x.length |
| have ok := runs_OK M x coins t |
| simp only [Small, ok.tm, ok.st, ok.inp, radix] |
| refine ⟨by omega, by have := (M.run x coins t).state.isLt; omega, ?_, ?_⟩ |
| · intro i; have := ((M.run x coins t).inputPos i).isLt; omega |
| · intro i |
| let s := cs * Nat.clog 2 (n+2) |
| have hv := @Zipped.bound ( (M.run x coins t).work i) _ _ s (ok.tapes i) |
| (le_trans (M.workPos_abs_le_space x coins t i) |
| (show (M.spaceThrough x coins t : ℤ) ≤ (s:ℤ) by exact_mod_cast ht t)) |
| (M.work_eq_false_outside ht t i) |
| have hz : 2^(2*s+1) ≤ 2*(2*(x.length+2))^(2*cs) := by |
| have e : 2*s=Nat.clog 2 (n+2)*(2*cs) := by dsimp [s]; ring |
| rw [e,pow_succ,pow_mul,Nat.mul_comm _ 2] |
| exact Nat.mul_le_mul_left 2 (Nat.pow_le_pow_left (two_pow_clog_le _) _) |
| omega |
|
|
| lemma minput_range (x : Word) (i : ℕ) (d : Direction) : |
| i ≤ minput x i d + 1 ∧ minput x i d ≤ i+1 := by |
| cases d <;> dsimp [minput] <;> grind |
|
|
| / |
| abbrev Hint (q w h : ℕ) := Bool × Fin (q+1) × (Fin h → Fin 3) × (Fin w → Bool) |
|
|
| def hint (A : R w h) (q : ℕ) (b : Bool) : Hint q w h := |
| (b,A.state q,fun i=> ⟨A.inp i%3,by omega⟩, fun k=> front (A.tapes k).2) |
|
|
| lemma step_inj (x : Word) (A A' : R w h) (b b' : Bool) |
| (hk : A.step M x b=A'.step M x b') (hh : A.hint q b=A'.hint q b') |
| (h : A.st<q+1) (h' : A'.st<q+1) : A=A' := by |
| simp only [hint,Prod.mk.injEq] at hh |
| obtain ⟨rfl,hst,hin,hq⟩ := hh |
| have he : A.inp=A'.inp := by |
| funext i |
| have hv := congrFun (congrArg R.inp hk) i |
| have hm := congrArg Fin.val (congrFun hin i) |
| simp only [step] at hv |
| have hs := minput_range x (A.inp i) ((A.action M x b).inputMove i) |
| have ht := minput_range x (A'.inp i) ((A'.action M x b).inputMove i) |
| dsimp only at hm |
| omega |
| have ha : A.action M x b=A'.action M x b := by rw [action,action,out,out,hst,he,hq] |
| refine R.ext ?_ ?_ he ?_ |
| · have H := congrArg R.tm hk; simp [step] at H; exact H |
| · simpa [R.state,Nat.mod_eq_of_lt h,Nat.mod_eq_of_lt h'] using congrArg Fin.val hst |
| · funext i |
| have hv := congrFun (congrArg tapes hk) i |
| simp only [step,ha] at hv |
| exact Zip.unique (congrFun hq i) hv |
|
|
| end R |
| end ExactDerandomization.Base |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Base |
|
|
| abbrev Vec (w : ℕ) := Fin w → ℕ |
|
|
| def wrap (m : ℕ) (a z : ℕ) := a+m*z |
| def enc (m : ℕ) (z : ℕ) : {d : ℕ} → Vec d → ℕ |
| | 0,_ => z |
| | d+1,f => wrap m (f 0) (enc m z (fun i : Fin d => f i.succ)) |
|
|
| def dec (m : ℕ) : (d z : ℕ) → Vec d |
| | 0, _ => Fin.elim0 |
| | d+1,z => Fin.cons (z%m) (dec m d (z/m)) |
|
|
| def upper (m : ℕ) : (d z : ℕ) → ℕ |
| | 0,z => z |
| | d+1,z => upper m d (z/m) |
|
|
| lemma wrap_lo {m a z} (h : a < m) : wrap m a z % m = a := by |
| rw [wrap, Nat.add_mul_mod_self_left,Nat.mod_eq_of_lt h] |
| lemma wrap_hi {m a z} (h : a < m) : wrap m a z / m = z := by |
| rw [wrap,Nat.add_mul_div_left _ _ (by omega),Nat.div_eq_of_lt h, Nat.zero_add] |
|
|
| lemma enc_dec (m d z : ℕ) : enc m (upper m d z) (dec m d z) = z := by |
| induction d generalizing z with |
| | zero => rfl |
| | succ d ih => |
| simp only [enc, upper,dec,Fin.cons_zero,Fin.cons_succ,ih,wrap, Nat.mod_add_div] |
|
|
| lemma dec_enc (m z : ℕ) {d : ℕ} (v : Vec d) (h : ∀ i, v i < m) : |
| dec m d (enc m z v) = v ∧ upper m d (enc m z v) = z := by |
| induction d with |
| | zero => exact ⟨funext (fun i => Fin.elim0 i),rfl⟩ |
| | succ d ih => |
| obtain ⟨e,e'⟩ := ih (fun i=>v i.succ) (fun i=>h _) |
| simp [enc,dec,upper,wrap_lo (h 0),wrap_hi (h 0),e,e'] |
| funext i; refine Fin.cases ?_ ?_ i <;> simp |
|
|
| lemma upper_le {a b} (m d) (h : a≤b) : upper m d a ≤ upper m d b := by |
| induction d generalizing a b with |
| | zero => exact h |
| | succ d ih => exact ih (Nat.div_le_div_right h) |
|
|
| lemma wrap_bound {m a z k} (h : a < m) (e : z<k) : wrap m a z < m*k := by |
| unfold wrap |
| nlinarith |
|
|
| lemma enc_bound {m z k d} (e : z<k) (v : Vec d) (h : ∀ i, v i < m) : |
| enc m z v < m^d * k := by |
| induction d with |
| | zero => simpa [enc] using e |
| | succ d ih => |
| calc enc m z v < m*(m^d*k) := wrap_bound (h _) (ih _ (fun i=>h _)) |
| _ = _ := by ring |
|
|
| namespace R |
| variable {w h : ℕ} |
|
|
| def id (A : R w h) (m : ℕ) := |
| enc m (enc m (enc m (wrap m A.st A.tm) A.inp) fun i=> (A.tapes i).1) fun i => (A.tapes i).2 |
|
|
| def recov (w h : ℕ) (m n : ℕ) : R w h := |
| let n1 := upper m w n |
| let n2 := upper m w n1 |
| let n3 := upper m h n2 |
| {tm:= n3/m |
| st:= n3%m |
| inp:= dec m h n2 |
| tapes:= fun i=> (dec m w n1 i,dec m w n i)} |
|
|
| lemma id_recov (m w h n) : |
| (recov w h m n).id m = n := by |
| unfold id recov wrap |
| simp only [Nat.mod_add_div, enc_dec] |
|
|
| lemma recov_id {A : R w h} {m} (he : A.Small m) : recov w h m (A.id m)=A := by |
| obtain ⟨_,hs,hi,ht⟩ := he |
| have hl (z : ℕ) := dec_enc m z (fun i=> (A.tapes i).1) (fun i=> (ht i).1) |
| have hr (z : ℕ) := dec_enc m z (fun i=> (A.tapes i).2) (fun i=> (ht i).2) |
| have hin (z : ℕ) := dec_enc m z A.inp hi |
| simp only [id, recov,(hr _).2,(hl _).2,(hin _).2,(hr _).1,(hl _).1, |
| (hin _).1,wrap_hi hs,wrap_lo hs] |
|
|
| def total (w h m : ℕ) := m^w * (m^w * (m^h*(m*m))) |
|
|
| lemma id_lt {A : R w h} {m} (he : A.Small m) : |
| A.id m < total w h m := |
| enc_bound (enc_bound (enc_bound (wrap_bound he.2.1 he.1) |
| _ he.2.2.1) _ fun i=>(he.2.2.2 i).1) _ fun i=>(he.2.2.2 i).2 |
|
|
| lemma recov_mono (m w h) (a b) (he : a≤b) : |
| (recov w h m a).tm ≤ (recov w h m b).tm := |
| Nat.div_le_div_right (upper_le _ _ (upper_le _ _ (upper_le _ _ he))) |
|
|
| end R |
| end ExactDerandomization.Base |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Base |
|
|
| / |
| be positive for building the graph) and controller space coefficient. |
| Semantics will justify these externally. -/ |
| structure Source (q w h : ℕ) where |
| mach : Machine q w h |
| cs : ℕ |
| c : ℕ |
| k : ℕ |
|
|
| namespace Source |
| variable {q w h : ℕ} (P : Source q w h) |
|
|
| def clock (x : Word) := polynomialClock P.c P.k x.length |
| def mrad (x : Word) := R.radix q P.cs P.c P.k x.length |
| def size (x : Word) := R.total w h (P.mrad x) |
| def dom (x : Word) := Finset.range (P.size x) |
|
|
| def row (x : Word) (n : ℕ) := R.recov w h (P.mrad x) n |
| def ident (x : Word) (A : R w h) := R.id A (P.mrad x) |
| def first (x : Word) := P.ident x (R.start P.mach) |
|
|
| instance decSmall (A : R w h) (m) : Decidable (A.Small m) := by unfold R.Small; infer_instance |
|
|
| def legal (x : Word) (A : R w h) : Prop := A.Small (P.mrad x) ∧ A.st < q+1 |
| instance decLegal (x : Word) (A : R w h) : Decidable (P.legal x A) := |
| inferInstanceAs (Decidable (_ ∧ _)) |
|
|
| def fin (x : Word) (n : ℕ) : Bool := |
| decide (P.legal x (P.row x n) ∧ (P.row x n).tm = P.clock x ∧ |
| (P.row x n).out P.mach = some true) |
|
|
| def next (x : Word) (n : ℕ) (b : Bool) : Option ℕ := |
| let a := P.row x n |
| let v := a.step P.mach x b |
| if P.legal x a ∧ a.tm < P.clock x ∧ P.legal x v then some (P.ident x v) |
| else none |
|
|
| def reward (x : Word) (n : ℕ) : ℚ := if P.fin x n then 1 else 0 |
|
|
| def edge (x : Word) (n j : ℕ) : ℕ := |
| (if P.next x n false=some j then 1 else 0)+(if P.next x n true=some j then 1 else 0) |
|
|
| def S (x : Word) (n j : ℕ) : ℚ := P.edge x n j / (2:ℚ) |
|
|
| lemma steps_to {x n b y} (h : P.next x n b = some y) : |
| P.legal x (P.row x n) ∧ (P.row x n).tm<P.clock x ∧ P.legal x (P.row x y) ∧ |
| (P.row x n).step P.mach x b=P.row x y := by |
| dsimp only [next] at h; split at h |
| · rename_i he |
| obtain rfl := Option.some.inj h |
| unfold row at he |
| simp only [row,ident, R.recov_id he.2.2.1]; exact ⟨he.1,he.2.1,he.2.2,trivial⟩ |
| · simp at h |
|
|
| lemma mem {x n} (h : P.legal x (P.row x n)) : n ∈ P.dom x := by |
| have e := R.id_lt h.1 |
| simp only [row,R.id_recov] at e; exact Finset.mem_range.mpr e |
|
|
| lemma forward {x n b y} (e : P.next x n b = some y) : n < y := by |
| by_contra! hy |
| have hm := R.recov_mono (P.mrad x) w h y n hy |
| have hk := congrArg R.tm (P.steps_to e).2.2.2 |
| simp only [row,R.step] at hk; omega |
|
|
| lemma S_nonneg (x n j) : 0≤ P.S x n j := by unfold S; positivity |
| lemma S_le (x n j) : P.S x n j ≤ 1 := by unfold S edge; split <;> split <;> norm_num |
|
|
| lemma S_pos {x n j} : |
| 0<P.S x n j ↔ P.next x n false=some j ∨ P.next x n true=some j := by |
| unfold S edge; split <;> split <;> simp_all |
|
|
| def payoff (f : ℕ → ℚ) (p : Option ℕ) : ℚ := p.elim 0 f |
| def avg (x : Word) (n : ℕ) (f : ℕ → ℚ) : ℚ := |
| (payoff f (P.next x n false) + payoff f (P.next x n true)) / 2 |
|
|
| open Finset |
| lemma avg_S (x n) (f) : |
| P.avg x n f = ∑ j ∈ P.dom x, P.S x n j * f j := by |
| let term (b : Bool) j : ℚ := if P.next x n b= some j then f j/2 else 0 |
| have he (b : Bool) : payoff f (P.next x n b)/2=∑ j∈P.dom x,term b j := by |
| cases h : P.next x n b with |
| | none => simp [term,payoff,h] |
| | some j => simp [term,payoff,h,P.mem (P.steps_to h).2.2.1] |
| have hk (j) : P.S x n j * f j= term false j + term true j := by |
| unfold S edge term; split <;> split <;> norm_num <;> ring |
| simp [avg,add_div,he,hk,sum_add_distrib] |
|
|
| lemma S_sub (x n) : ∑ j ∈ P.dom x, P.S x n j ≤ 1 := by |
| have h := P.avg_S x n (fun _=>1) |
| simp at h |
| rw [← h]; unfold avg |
| cases P.next x n false <;> cases P.next x n true <;> norm_num [payoff] |
|
|
| lemma dead {x n} (e : P.fin x n=true) (b) : P.next x n b = none := by |
| simp only [fin,decide_eq_true_eq] at e |
| simp [next,e.2.1] |
|
|
| lemma out_degree (x n) : |
| ((P.dom x).filter (fun j=>0<P.S x n j)).card ≤ 2 := by |
| let f (b : Bool) := (P.next x n b).getD 0 |
| have he : (P.dom x).filter (fun j=>0<P.S x n j) ⊆ Finset.univ.image f := by |
| intro j h |
| obtain a|a := (S_pos P).1 (Finset.mem_filter.1 h).2 |
| · exact Finset.mem_image.2 ⟨false, Finset.mem_univ _,by simp [f,a]⟩ |
| · exact Finset.mem_image.2 ⟨true, Finset.mem_univ _,by simp [f,a]⟩ |
| exact le_trans (Finset.card_le_card he) (by |
| simpa only [Finset.card_univ,Fintype.card_bool] using Finset.card_image_le (s:=Finset.univ) (f:=f)) |
|
|
| lemma in_degree (x y) : |
| ((P.dom x).filter (fun n=>0<P.S x n y)).card ≤ Fintype.card (R.Hint q w h) := by |
| classical |
| let v := (P.dom x).filter (fun n=>0<P.S x n y) |
| change v.card ≤ _ |
| let b n : Bool := if P.next x n true=some y then true else false |
| have hs (n) (hn : n∈v) : P.next x n (b n)=some y := by |
| have hv := P.S_pos.1 (Finset.mem_filter.1 hn).2 |
| dsimp only [b]; split <;> grind |
| let code (n : ↥v) := (P.row x n.val).hint q (b n.val) |
| have hi : Function.Injective code := by |
| intro n m he |
| have hn := P.steps_to (hs n n.prop) |
| have hm := P.steps_to (hs m m.prop) |
| have e := R.step_inj P.mach x _ _ _ _ (hn.2.2.2.trans hm.2.2.2.symm) he hn.1.2 hm.1.2 |
| apply Subtype.ext |
| simpa only [row, ident,R.id_recov] using congrArg (P.ident x) e |
| simpa using Fintype.card_le_of_injective _ hi |
|
|
| / |
| def potential (x : Word) : ℕ → ℕ → ℚ |
| | 0 => P.reward x |
| | k+1 => fun n=> P.reward x n + P.avg x n (potential x k) |
|
|
| lemma bounded (x k n) : 0≤P.potential x k n ∧ P.potential x k n ≤ 1 := by |
| induction k generalizing n with |
| | zero => unfold potential reward; split <;> norm_num |
| | succ k ih => |
| cases h : P.fin x n with |
| | true => simp [potential,reward,h,avg,P.dead h,payoff] |
| | false => |
| have H (b) : 0 ≤ payoff (P.potential x k) (P.next x n b) ∧ |
| payoff (P.potential x k) (P.next x n b) ≤ 1 := by |
| cases P.next x n b <;> simp [payoff, ih] |
| have ht := H true |
| have hf := H false |
| simp [potential,reward,h,avg] |
| constructor <;> linarith |
|
|
| lemma stable (x n k) (h : P.clock x ≤ (P.row x n).tm+k) : |
| P.potential x k n=P.potential x (k+1) n := by |
| induction k generalizing n with |
| | zero => |
| have he (b) : P.next x n b=none := by |
| simp only [Nat.add_zero] at h; simp [next,not_lt.2 h] |
| simp [potential,avg,he,payoff] |
| | succ k ih => |
| have he (b) : payoff (P.potential x k) (P.next x n b) = |
| payoff (P.potential x (k+1)) (P.next x n b) := by |
| cases hb : P.next x n b with |
| | none => rfl |
| | some j => |
| apply ih |
| have H := congrArg R.tm (P.steps_to hb).2.2.2 |
| simp only [R.step] at H |
| omega |
| change P.reward x n+ _=P.reward x n+_ |
| unfold avg; rw [he,he] |
|
|
| def pr (x : Word) := P.potential x (P.clock x) |
|
|
| lemma pr_eq (x n) : P.pr x n=P.reward x n + P.avg x n (P.pr x) := by |
| exact stable P x n (P.clock x) (by omega) |
|
|
| abbrev Space (P : Source q w h) := |
| ∀ x coins t, P.mach.spaceThrough x coins t≤P.cs * Nat.clog 2 (x.length+2) |
| def walker (x : Word) (coins : CoinTape) (t : ℕ) := P.ident x (R.runs P.mach x coins t) |
|
|
| lemma visited (e : Space P) (x : Word) (coins t) (h : t≤P.clock x) : |
| P.row x (P.walker x coins t) = R.runs P.mach x coins t ∧ |
| P.legal x (R.runs P.mach x coins t) ∧ (R.runs P.mach x coins t).tm=t := by |
| have H := @R.runs_small q w _ P.mach x coins P.cs P.c P.k (e x coins) t h |
| have I := R.runs_OK P.mach x coins t |
| exact ⟨R.recov_id H,⟨H,I.st ▸ ((P.mach.run x coins t).state).isLt⟩,I.tm⟩ |
|
|
| lemma mem_first (e : Space P) (x) : P.first x∈ P.dom x := by |
| let coins : CoinTape := fun _=>false |
| obtain ⟨h,k,_⟩ := P.visited e x coins 0 (Nat.zero_le _) |
| exact P.mem (n:=P.walker x coins 0) (h.symm ▸ k) |
|
|
| lemma step_true (e : Space P) (x coins t) (h : t<P.clock x) : |
| P.next x (P.walker x coins t) (coins t) = |
| some (P.walker x coins (t+1)) ∧ P.fin x (P.walker x coins t) = false := by |
| obtain ⟨H,G,S⟩ := P.visited e x coins t (le_of_lt h) |
| obtain ⟨_,T,_⟩ := P.visited e x coins (t+1) h |
| simp only [R.runs] at T |
| simp only [next,fin,H,G,S,h,T,true_and,ite_true] |
| simp [walker,R.runs,Nat.ne_of_lt h] |
|
|
| lemma pr_end (e : Space P) (x coins) : |
| P.pr x (P.walker x coins (P.clock x)) = |
| if P.mach.output (P.mach.run x coins (P.clock x)).state = some true then 1 else 0 := by |
| obtain ⟨H,G,S⟩ := P.visited e x coins (P.clock x) le_rfl |
| rw [pr_eq] |
| simp [avg,reward,fin,next,H,G,S,payoff,R.runs_out] |
|
|
| lemma same (x : Word) (coins₁ coins₂ : CoinTape) (t : ℕ) |
| (h : ∀ j<t, coins₁ j=coins₂ j) : |
| P.walker x coins₁ t=P.walker x coins₂ t := by |
| unfold walker; congr 1 |
| induction t with |
| | zero=>rfl |
| | succ t ih=> rw [R.runs,h t (by omega), ih (fun j hj=>h j (by omega)), ← R.runs] |
|
|
| abbrev Tapes (n : ℕ) := Fin n → Bool |
|
|
| def Toggle {n : ℕ} (i : Fin n) : Equiv.Perm (Tapes n) := |
| let f := fun (b : Tapes n) j => if i=j then !b j else b j |
| have H : Function.LeftInverse f f := fun b=>by funext j; dsimp [f]; split <;> simp_all |
| ⟨f,f,H,H⟩ |
|
|
| lemma fair (e : Space P) (x : Word) : |
| P.pr x (P.first x)=P.mach.acceptanceProbability x (P.clock x) := by |
| let k := P.clock x |
| let f (b : Tapes k) (t) := P.walker x (Machine.extendCoins b) t |
| let g (t) (b : Tapes k) := P.pr x (f b t) |
| have HH (t) (ht : t<k) (b : Tapes k) : |
| g t b = (g (t+1) b + g (t+1) (Toggle ⟨t,ht⟩ b))/2 := by |
| let i : Fin k := ⟨t,ht⟩ |
| let l := Toggle i b |
| let w := Machine.extendCoins |
| (t:=k) |
| have hv : f b t=f l t := by |
| apply P.same |
| intro j hj |
| have hk : j<k := by omega |
| have hne : i.val≠j := by dsimp [i]; omega |
| have hne' : i ≠ ⟨j,hk⟩ := fun h=>hne (congrArg Fin.val h) |
| simp [Machine.extendCoins, l, Toggle,hk,hne'] |
| obtain ⟨hn,Hp⟩ := P.step_true e x (w b) t ht |
| obtain ⟨hn',-⟩ := P.step_true e x (w l) t ht |
| have h1 : w b t=b i := Machine.extendCoins_apply b i |
| have h2 : w l t= (!b i) := |
| (Machine.extendCoins_apply l i).trans (by simp [l,Toggle]) |
| rw [h1] at hn |
| rw [h2] at hn' |
| change P.next x (f b t) (b i)=some (f b (t+1)) at hn |
| change P.next x (f l t) (!b i)=some (f l (t+1)) at hn' |
| change P.fin x (f b t)=false at Hp |
| rw [← hv] at hn' |
| change P.pr x (f b t) = (P.pr x (f b (t+1)) + P.pr x (f l (t+1))) / 2 |
| rw [pr_eq] |
| cases h : b i <;> simp only [h, Bool.not_true,Bool.not_false] at hn hn' <;> |
| simp [reward,Hp,avg,payoff,hn,hn',add_comm] |
| have hs (t) (ht : t≤k) : ∑ b, g 0 b= ∑ b, g t b := by |
| induction t with |
| | zero => rfl |
| | succ t ih => |
| have hlt : t<k := ht |
| rw [ih (by omega)] |
| calc |
| _ = ∑ b, (g (t+1) b+g (t+1) (Toggle ⟨t,hlt⟩ b))/2 := |
| Finset.sum_congr rfl (fun b _=> HH t hlt b) |
| _ = _ := by |
| rw [← Finset.sum_div, Finset.sum_add_distrib,Fintype.sum_equiv |
| (Toggle ⟨t,hlt⟩) _ (g (t+1)) (fun b=>rfl)] |
| ring |
| let p (b : Tapes k) := P.mach.output (P.mach.run x (Machine.extendCoins b) k).state = some true |
| let : DecidablePred p := fun i => inferInstanceAs (Decidable (_ = some true)) |
| have hv (b) : g k b = if p b then 1 else 0 := P.pr_end e x _ |
| have hz (b) : g 0 b = P.pr x (P.first x) := rfl |
| have he := hs k le_rfl |
| simp only [hz,hv] at he |
| rw [Finset.sum_const, Finset.card_univ, Fintype.card_fun, Fintype.card_bool, Fintype.card_fin] at he |
| unfold Machine.acceptanceProbability |
| rw [eq_div_iff (by positivity),mul_comm] |
| change (2:ℚ)^k * P.pr x (P.first x) = _ |
| rw [Finset.card_filter] |
| simpa using he |
|
|
| end Source |
| end ExactDerandomization.Base |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Base |
|
|
| open Counter |
|
|
| lemma enc_E {w} (m z : NE) (f : Fin w → NE) (hm : E m) (hz : E z) |
| (h : ∀ i, E (f i)) : E (fun x a=> enc (m x a) (z x a) (fun i=>f i x a)) := by |
| induction w with |
| | zero => exact hz |
| | succ w ih => |
| exact (h 0).add (hm.mul (ih (fun i=>f i.succ) (fun i=> h i.succ))) |
|
|
| lemma dec_E {m n : NE} (hm : E m) (hn : E n) (d : ℕ) : |
| E (fun x a=>upper (m x a) d (n x a)) ∧ |
| ∀ i, E (fun x a=>dec (m x a) d (n x a) i) := by |
| induction d generalizing n with |
| | zero => exact ⟨hn,fun i=>Fin.elim0 i⟩ |
| | succ d ih => |
| obtain ⟨h,h'⟩ := ih (hn.div hm) |
| refine ⟨h,fun i=> Fin.cases ?_ ?_ i⟩ |
| · simpa only [dec,Fin.cons_zero] using (hn.mod hm) |
| · intro i; simpa only [dec,Fin.cons_succ] using h' i |
|
|
| lemma PickAND {p q : Word → Store → Prop} [∀ x, DecidablePred (p x)] [∀ x, DecidablePred (q x)] |
| (h : Pick (fun x a=>decide (p x a))) (k : Pick (fun x a => decide (q x a))) : |
| Pick (fun x a => decide (p x a ∧ q x a)) := by |
| simpa using h.and k |
|
|
| lemma front_E {n : NE} (h : E n) : Pick (fun x a=>front (n x a)) := |
| Pick.test_eq (h.mod (E.const 2)) (E.const 1) |
|
|
| lemma push_E {n : NE} {f : Word → Store → Bool} (h : E n) (e : Pick f) : |
| E (fun x a=>push (f x a) (n x a)) := |
| (e.ite (E.const 1) (E.const 0)).add ((E.const 2).mul h) |
|
|
| variable {w h q : ℕ} |
|
|
| structure RE (f : Word → Store → R w h) : Prop where |
| tim : E fun x a=> (f x a).tm |
| st : E fun x a=> (f x a).st |
| inp (i : Fin h) : E fun x a=> (f x a).inp i |
| ll (i : Fin w) : E fun x a=> ((f x a).tapes i).1 |
| rr (i : Fin w) : E fun x a=> ((f x a).tapes i).2 |
|
|
| namespace RE |
|
|
| variable {f : Word → Store → R w h} |
|
|
| lemma code {m : NE} (hf : RE f) (hm : E m) : E (fun x a=>(f x a).id (m x a)) := |
| enc_E _ _ _ hm (enc_E _ _ _ hm (enc_E _ _ _ hm (hf.st.add (hm.mul hf.tim)) hf.inp) |
| hf.ll) hf.rr |
|
|
| lemma recover {m n : NE} (hm : E m) (hn : E n) : |
| RE (fun x a=>R.recov w h (m x a) (n x a)) := by |
| obtain ⟨he0,h0⟩ := dec_E hm hn w |
| obtain ⟨he1,h1⟩ := dec_E hm he0 w |
| obtain ⟨he2,h2⟩ := dec_E hm he1 h |
| exact ⟨he2.div hm,he2.mod hm,h2,h1,h0⟩ |
|
|
| lemma small {m : NE} (hf : RE f) (hm : E m) : |
| Pick (fun x a=> decide ((f x a).Small (m x a))) := |
| PickAND (Pick.test_lt hf.tim hm) (PickAND (Pick.test_lt hf.st hm) |
| (PickAND (Pick.all _ (fun i=> Pick.test_lt (hf.inp i) hm)) |
| (Pick.all _ (fun i=> PickAND (Pick.test_lt (hf.ll i) hm) |
| (Pick.test_lt (hf.rr i) hm))))) |
|
|
| lemma stPick (hf : RE f) (q) : Pick (fun x a => (f x a).state q) := |
| Pick.pos (hf.st.mod (E.const _)) |
|
|
| lemma choose (hf : RE f) (M : Machine q w h) (b : Bool) : |
| Pick (fun x a => (f x a).action M x b) := by |
| let v x a := fun i => Counter.scan x ((f x a).inp i) |
| let z x a := fun i=> front ((f x a).tapes i).2 |
| have hv : Pick v := Pick.tuple (fun i=> Pick.read (hf.inp i)) |
| have hz : Pick z := Pick.tuple (fun i=> front_E (hf.rr i)) |
| let doIt := fun (s : Fin (q+1)) (u : Fin h → InputSymbol) (n : Fin w → Bool) => |
| match M.output s with |
| | none=> M.transition s u n b |
| | some _=> ⟨s,n,fun _=> .stay,fun _=>.stay⟩ |
| exact (hf.stPick q).bind (g:=fun s x a=>doIt s (v x a) (z x a)) |
| (fun s=> hv.bind (g:=fun u x a => doIt s u (z x a)) (fun u => hz.map (doIt s u))) |
|
|
| lemma step (hf : RE f) (M : Machine q w h) (b : Bool) : |
| RE (fun x a => (f x a).step M x b) := by |
| have he := hf.choose M b |
| constructor |
| · exact hf.tim.succ |
| · exact he (fun z _ _=>z.nextState.val) (fun _=> E.const _) |
| · intro i |
| refine (he.map (fun z=>z.inputMove i)) |
| (fun d x a=> R.minput x ((f x a).inp i) d) (fun d=>?_ ) |
| cases d |
| · exact (hf.inp i).pred |
| · exact hf.inp i |
| · exact E.ite_lt (hf.inp i) E.length.succ (hf.inp i).succ (hf.inp i) |
| · intro i |
| apply he (fun z x a => (((f x a).tapes i).act (z.write i) (z.workMove i)).1) |
| intro z |
| cases H : z.workMove i with |
| | stay => exact hf.ll i |
| | right => exact push_E (hf.ll i) (Pick.const _) |
| | left => exact (hf.ll i).div (E.const 2) |
| · intro i |
| apply he (fun z x a => (((f x a).tapes i).act (z.write i) (z.workMove i)).2) |
| intro z |
| cases H : z.workMove i with |
| | stay => exact push_E ((hf.rr i).div (E.const 2)) (Pick.const _) |
| | right => exact (hf.rr i).div (E.const 2) |
| | left => exact push_E (push_E ((hf.rr i).div (E.const 2)) (Pick.const _)) (front_E (hf.ll i)) |
| end RE |
|
|
| namespace Source |
|
|
| variable (P : Source q w h) |
|
|
| lemma eClock : E (fun x _=>P.clock x) := |
| (E.const _).mul ((E.length.add (E.const 2)).pow_const _) |
|
|
| lemma eRad : E (fun x _=>P.mrad x) := |
| (((E.const (q+2)).add P.eClock).add (E.length.add (E.const 2))).add |
| ((E.const 2).mul (((E.const 2).mul (E.length.add (E.const 2))).pow_const _)) |
|
|
| lemma eSize : E (fun x _=>P.size x) := (P.eRad.pow_const _).mul |
| ((P.eRad.pow_const _).mul ((P.eRad.pow_const _).mul (P.eRad.mul P.eRad))) |
|
|
| lemma eFirst : E (fun x _=>P.first x) := |
| RE.code (f:=fun _ _=>R.start P.mach) |
| ⟨E.const _,E.const _,fun _=>E.const _,fun _=>E.const _,fun _=>E.const _⟩ P.eRad |
|
|
| lemma eLegal {v : Word → Store → R w h} (hv : RE v) : |
| Pick (fun x a=> decide (P.legal x (v x a))) := |
| PickAND (hv.small P.eRad) (Pick.test_lt hv.st (E.const (q+1))) |
|
|
| lemma eReward {f : NE} (hf : E f) : |
| Pick (fun x a=> P.fin x (f x a)) := by |
| have hk : RE (fun x a=> P.row x (f x a)) := RE.recover P.eRad hf |
| exact PickAND (P.eLegal hk) (PickAND (Pick.test_eq hk.tim P.eClock) |
| ((hk.stPick q).map (fun s=>decide (P.mach.output s=some true)))) |
|
|
| lemma eWeight {f g : NE} (hf : E f) (hg : E g) : |
| E (fun x a=> P.edge x (f x a) (g x a)) := by |
| let v x a := P.row x (f x a) |
| have hk : RE v := RE.recover P.eRad hf |
| have he (b : Bool) : E (fun x a=> if P.next x (f x a) b=some (g x a) then 1 else 0) := by |
| let z x a := R.step P.mach (v x a) x b |
| have hz : RE z := hk.step P.mach b |
| have hc := hz.code P.eRad |
| have ht := PickAND (P.eLegal hk) (PickAND (Pick.test_lt hk.tim P.eClock) (P.eLegal hz)) |
| convert ht.ite (hc.ite_eq hg (E.const 1) (E.const 0)) (E.const 0) using 1 |
| ext x a |
| simp [next,v,z,ident] ; grind |
| exact (he false).add (he true) |
|
|
| end Source |
| end ExactDerandomization.Base |
|
|
| end |
|
|
| end OAI |
|
|
