File size: 3,952 Bytes
472a116 | 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 | import OAI.Computability.SpaceSimulation.OneTape.Caps
import OAI.Computability.SpaceSimulation.OneTape.Growth
namespace OAI
/-!
One-tape simulation in two-fifths-power space, following OpenAI's
“Simulating One-Tape Time in Two-Fifths-Power Space”. The capped and
unknown-time bounds include all intermediate work storage and keep the
accessor and simulator fixed independently of the input and time cap.
-/
namespace Fifths
namespace Single
open Entry Cost
variable {X : Type} (M : Single X)
/-- Ordinary capped access condition. Log is binary (Cost.Log n =
log base two of (n+2)). Real constants. -/
def Access (A : M.Sym) (p q : ℝ) (x : List X) (T : ℕ) : Prop :=
∀ (h : M.Tag) (l : ℤ), Inside T l →
∃ s : ℕ, (s:ℝ) ≤ p * (Log T)^q ∧
A.Within (binaryIn x (M.arg T h l)) (M.sensor x h l) s
/-- Widen all promised runs of the accessor to a pointwise
integer bound. Parameter is integer so tight floors immaterial. -/
theorem accessed (A : M.Sym) (p q : ℝ) (hp : 1 ≤ p) :
∃ d c : ℕ, ∀ (x : List X) (T : ℕ), M.Access A p q x T →
M.Gives A x T (c*(bound d T + 1)) := by
obtain ⟨d,c,h⟩ := absorbs p q hp
refine ⟨d,c,?_⟩
intro x T e g u a
obtain ⟨s,g,l⟩ := e g u a
exact l.mono (by exact_mod_cast g.trans (h T))
/-- With binary cap as a separate read-only argument. Single
simulator for all promised input/cap pairs. Real pointwise space
bound (in particular a soft-O bound). `exponent` = 2/5. -/
theorem capped [Fintype X] (A : M.Sym) (p q : ℝ) (hp : 1 ≤ p) (_hq : 1 ≤ q) :
∃ (N : TM X Unit M.Outcome) (e : ℕ) (c : ℝ), 0 < c ∧
∀ (x : List X) (T : ℕ), 2 ≤ T → M.Access A p q x T →
∃ b : ℕ, N.Within (binaryIn x (fun _ => T)) (M.outcome x T) b ∧
(b:ℝ) ≤ c*(T:ℝ)^exponent*(Log T)^e := by
classical
obtain ⟨d,c,H⟩ := M.accessed A p q hp
let I := {i : List X × ℕ // 2 ≤ i.2 ∧ M.Access A p q i.1 i.2}
let x := fun i : I => i.val.1
let T := fun i : I => i.val.2
let S := fun i : I => bound d (T i)
let f := fun i : I => M.outcome (x i) (T i)
let e : M.Outcome ↪ ℕ := ⟨Entry.code,Entry.code_inj _⟩
have l : Comp x S T (fun i => e (f i)) :=
M.cappedRegister A d (Comp.refl (capFits d T)) (Scaled.refl S)
⟨c,fun i => H (x i) (T i) i.property.2⟩
obtain ⟨N,u,w⟩ := Comp.withBinary (M.finish M.beginState) e l
refine ⟨N,d+2,((u:ℝ)+1)*2*factor d,?_,?_⟩
· have := fpos d; positivity
intro x t g h
exact ⟨_,w (⟨(x,t),g,h⟩ : I),scaledReal d u g⟩
/-- Simulator with no cap input, an actual time t being used only
to state the bound. If already halted at t, reports that outcome;
under the promises, halts within the stated space. -/
theorem unknown [Fintype X] (A : M.Sym) (p q : ℝ) (hp : 1 ≤ p) (_hq : 1 ≤ q) :
∃ (N : TM X Empty M.Outcome) (e : ℕ) (c : ℝ), 0 < c ∧
∀ (x : List X), (∀ T, 2 ≤ T → M.Access A p q x T) →
∀ (t : ℕ), (M.outcome x t).2 = true →
∃ b, N.Within (files x) (M.outcome x t) b ∧
(b:ℝ) ≤ c*((t:ℝ)+2)^exponent*(Log t)^e := by
classical
obtain ⟨d,c,H⟩ := M.accessed A p q hp
let I := {i : List X × ℕ //
(∀ T, 2 ≤ T → M.Access A p q i.1 T) ∧ (M.outcome i.1 i.2).2 = true}
let x := fun i : I => i.val.1
let t := fun i : I => i.val.2
let S := fun i : I => bound d (t i + 2)
let f := fun i : I => M.outcome (x i) (t i)
let e : M.Outcome ↪ ℕ := ⟨Entry.code,Entry.code_inj _⟩
have l : Comp x S (fun _ => 0) (fun i => e (f i)) :=
M.noCapRegister A d c (fun i : I => i.property.2)
(fun (i : I) T p => H (x i) T (i.property.1 T p))
obtain ⟨N,u,w⟩ := Comp.withoutBinary (M.finish M.beginState) e l
refine ⟨N,d+2,((u:ℝ)+1)*2*factor d*2^(d+2),?_,?_⟩
· have := fpos d; positivity
intro x h t q
exact ⟨_,w (⟨(x,t),h,q⟩ : I),scaledShift d u t⟩
end Single
end Fifths
end OAI
|