lean/OAI/Computability/Logspace/AllocationPrograms.lean

import OAI.Computability.Logspace.ContourTraversal

namespace OAI

/-!
Guarded allocation and finite instruction interfaces for recursive queries.

From OpenAI, *Exact Derandomization of Logarithmic Space: L = RL = BPL*.
-/

set_option autoImplicit true

section

/-! Generate allocation guards in LF. -/
namespace ExactDerandomization.Mint
open Relay Swirl Counter Finset
abbrev Node := Lore ℕ
abbrev Bean := Lore Seat

structure Rune where
   mode : Cub Node ℕ
   slip : Cub Node ℕ
   next : Cub Bean ℕ
   token : Cub Bean ℕ
   initMark : Cub Bean Bool

structure Valve where
   W : Cub ℕ ℕ
   T : Cub ℕ ℕ
   D : Cub ℕ ℕ
   depth : Cub ℕ ℕ
   clock : Cub ℕ ℕ
   tap : Cub ℕ Bool
   voted : Cub Node Bool
   reach : Bool → Cub Node ℕ
   storeU : Cub ℕ ℕ

structure Mill where
    A : ℕ
    r : Rune
    v : Valve
namespace Mill
variable (p:Mill)
def O (x:Word) (q:ℕ):Level:= ⟨p.v.W.f x q,p.v.T.f x q⟩
def E0 (x:Word) (q:ℕ):Level:=⟨p.v.depth.f x q,p.v.clock.f x q⟩
def shoot (_:Mill)(A:ℕ)(_:Word)(a:Node) := (caplen a.2)^A
lemma shootK : Kn (p.shoot p.A) := Kn.power _ (Kn.caplenK.comp Kn.next)
def total (x:Word)(q:ℕ):ℕ := min (p.v.storeU.f x q) (2^charge p.A (p.v.W.f x q) (p.v.T.f x q))
lemma totalK : Kn p.total :=
   Kn.cap p.v.storeU.runs (Kn.fix 2) (((Kn.fix p.A).times p.v.T.runs).add
                                                  ((Kn.fix (p.A*p.A)).times p.v.W.runs))

def loanP (x:Word) (a:Bean):Prop :=
    let q:=a.1
    let v:=a.2.1
    let z:=a.2.2
    let u:=p.O x q
    let L:=p.E0 x z
    L.w + p.v.D.f x q≤u.w ∧ span p.A (u.w-L.w) u.t L.t (lb v+1)
instance loanD (x:Word) (a:Bean):Decidable (p.loanP x a):=by unfold loanP span; infer_instance
def loan (x:Word)(a:Bean):Bool:= decide (p.loanP x a)

lemma conj {α} [Wire α] (h j : PT α Bool) (he:Kn h) (hs:Kn j):
   Kn (fun x a=> h x a&&j x a):=by
   convert he.cond hs (Kn.fix false) using 1
   ext x a; cases e:h x a <;> simp []
lemma loanK : Kn p.loan:= by
   have ht: Kn (fun (_:Word)(a:Bean)=>a.1):=Kn.first
   have hv: Kn (fun (_:Word)(a:Bean)=>a.2):=Kn.next
   have hf:=p.v.W.runs.comp ht; have he:=p.v.D.runs.comp ht
   have hz:=p.v.depth.runs.comp hv.right; have ha := p.v.clock.runs.comp hv.right
   have hc: Kn (fun (_:Word)(_a:Bean)=>p.A):=Kn.fix _
   have hl:= ((hv.left.bl.succ).add (hc.times ha)).le
             ((hc.times (p.v.T.runs.comp ht)).add (((hc.times hc).times (hf.sub hz))))
   convert conj _ _ ((hz.add he).le hf) hl using 1
   ext x a
   simp only [loan, loanP, span, O, E0]
   exact Bool.decide_and ..

def axis (_:Word)(a:Bean):Node :=(a.1,a.2.1)
lemma axisK : Kn axis:=Kn.first.tuple Kn.next.left

def road (b:Bool) (x:Word) (a:Bean) :=
    let n:=axis x a
    let s:=p.r.slip.f x n
    if p.r.mode.f x n ≤ 1 then s else p.v.reach b |>.f x (s,p.r.token.f x a)
lemma roadK (b) : Kn (p.road b):=
    (p.r.mode.runs.comp axisK).cond_le (Kn.fix 1) (p.r.slip.runs.comp axisK)
       ((p.v.reach b).runs.comp ((p.r.slip.runs.comp axisK).tuple p.r.token.runs))

def limits (x:Word) (a:Bean):Bool :=
   decide (a.2.2< p.total x a.1) && decide (a.2.2 < p.shoot p.A x (axis x a))
lemma limitsK: Kn p.limits := conj _ _ (Kn.next.right.lt (p.totalK.comp Kn.first))
                                                   (Kn.next.right.lt (p.shootK.comp axisK))
def good0 (x:Word)(a:Bean):Bool:=
  let m:=p.r.mode.f x (axis x a)
  let t:=p.r.slip.f x (axis x a)
  let b:=p.r.token.f x a
  let z:= fun u=>p.loan x (a.1,a.2.1,p.road u x a)
  if m=0 then true else
   (z true && z false) && (if m=1 then p.v.tap.f x t else
          p.v.voted.f x (t,b) && decide (p.r.next.f x (a.1,a.2.1,b)=a.2.2+1))
lemma good0K : Kn p.good0:= by
   have ha : Kn (fun (_:Word)(a:Bean)=>a.1):=Kn.first
   have hb : Kn (fun (_:Word)(a:Bean)=>a.2):=Kn.next
   have h:=p.r.mode.runs.comp axisK; have he:=p.r.slip.runs.comp axisK
   have hv(b:Bool) := p.loanK.comp (ha.tuple (hb.left.tuple (p.roadK b)))
   exact h.cond_eq (Kn.fix 0) (Kn.fix _) (conj _ _ (conj _ _ (hv true) (hv false))
        (h.cond_eq (Kn.fix 1) (p.v.tap.runs.comp he)
           (conj _ _ (p.v.voted.runs.comp (he.tuple p.r.token.runs))
            ((p.r.next.runs.comp (ha.tuple (hb.left.tuple p.r.token.runs))).eq (hb.right.succ)))))
def permit (x:Word)(a:Bean):Bool:= (p.limits x a && p.limits x (a.1,a.2.2,a.2.1)) && p.good0 x a
lemma permitK : Kn p.permit:=conj _ _ (conj _ _ p.limitsK
          (p.limitsK.comp (Kn.first.tuple (Kn.next.right.tuple Kn.next.left)))) p.good0K

def bud :Bud :=⟨⟨_,p.shootK⟩, p.r.initMark,⟨_,p.permitK⟩,p.r.mode,p.r.next,p.r.token,fun b=>⟨_, p.roadK b⟩⟩

/-- semantic call responses -/
structure Fuel where
    l:Lot
    q:ℕ
    domain: Finset ℕ
    hand:ℕ→ℕ
    echo:ℕ→ℕ→ℕ
    stream:ℕ→ℕ→Bool→ℕ→Option ℕ
abbrev price := p.A*(2*p.A+40)
abbrev slipk (s:Fuel)(x) := p.r.slip.f s.l.x (s.q,x)
def clay (s:Fuel):Clay:=
   ⟨s.l,p.O s.l.x s.q,p.v.D.f s.l.x s.q,s.q,p.price,
       range (p.total s.l.x s.q),s.domain,s.hand,
       fun v x=>s.echo (p.slipk s v) x, fun v=>s.stream (p.slipk s v)⟩
abbrev entitled (s:Fuel)(q:ℕ) := ∃ v,p.loanP s.l.x (s.q,v,q)

def motor (s:Fuel) (q z:ℕ) (b:Bool) (c:ℕ): Site :=
    match s.stream q z b c with
    | none=> (0,s.hand c)
    | some w=> (1,s.hand w)
structure Fires (s:Fuel):Prop where
   ax: 1≤ p.A
   wp : 1 ≤ (p.O s.l.x s.q).w
   openL : ∀ q,s.l.book q=p.E0 s.l.x q
   hands : ∀ i∈s.domain,s.hand i ≤ s.l.F.limit
   ring : ∀ t,p.v.tap.f s.l.x t=true → entitled p s t → ∀ i∈s.domain,
       Boots s.l.x s.l.F s.l.P t s.l.P (0,s.hand i) (s.echo t i,s.hand i)
   rout : ∀ t z,p.v.voted.f s.l.x (t,z)=true →
      (∀ b,entitled p s ((p.v.reach b).f s.l.x (t,z))) →
      ∀ i∈s.domain,∀ b, Boots s.l.x s.l.F s.l.P ((p.v.reach b).f s.l.x (t,z)) s.l.P (0,s.hand i)
                          (motor s t z b i) ∧
                        ∀ j,s.stream t z b i=some j → j∈s.domain ∧ s.stream t z (!b) j=some i
   uniq : ∀ {t i z y a b}, s.stream t z true i=some a → s.stream t y true i=some b →
          z=y

lemma plusbase {a b:ℕ} (x:Bool) :
   lb (enc ((x,a,b):Panel))+1≤lb a*2+lb b+7:=by
   have hx:=measure_pair x (a,b)
   have hv:= measure_pair a b
   have he : Relay.measure x=1 := by cases x<;> rfl
   change Relay.measure (x,a,b)+1 ≤ Relay.measure a*2+Relay.measure b+7
   omega
lemma lumax {v i}(_:1≤p.A)
    (h:i≤ (caplen v)^p.A) :
    lb i≤ lb v*p.A+1 := by
   have he:=lb_mono h
   rw [caplen,← pow_mul,lb_shift] at he
   exact he
lemma cheaply {i v}(hA:1≤p.A) (h:i≤ (caplen v)^p.A) (b y:Bool) :
   lb (enc ((y,Bud.invert b (v,i)):Panel))+1 ≤ (2*p.A+40)*lb v:= by
   have hs:=p.lumax hA h
   cases b
   · change lb (enc (y,i,v))+1≤_

     have he:= plusbase (a:=i) (b:=v) y
     nlinarith [lb_pos v]
   change lb (enc (y,v,i))+1≤_
   have he:=plusbase (a:=v) (b:=i) y
   nlinarith [lb_pos v]

end Mill
end ExactDerandomization.Mint

end

section

namespace ExactDerandomization.Mint
open Relay Swirl Counter Finset
namespace Mill
variable (p:Mill) (s:Fuel)

abbrev view (v i:ℕ):Bean :=(s.q,v,i)
abbrev compo (v) := p.r.mode.f s.l.x (s.q,v)
abbrev label (v _ z:ℕ) := p.r.next.f s.l.x (view s v z)
abbrev wherep (v i) := p.r.token.f s.l.x (view s v i)

abbrev faith (v t) := p.loanP s.l.x (view s v t)
abbrev afoot (v) :=
    p.v.tap.f s.l.x (p.slipk s v)=true ∧ p.faith s v (p.slipk s v)
abbrev swept (v i:ℕ)(b:Bool) :=
   (p.v.reach b).f s.l.x (p.slipk s v,i)
abbrev swift (v z:ℕ) :=
      p.v.voted.f s.l.x (p.slipk s v,z)=true ∧ ∀ b,p.faith s v (p.swept s v z b)

lemma purity {v i} (h:p.compo s v=0) :
    p.good0 s.l.x (view s v i)=true :=by unfold compo at h; simp [good0,axis,h]
lemma bright {v i} (h:p.compo s v=1) :
    p.good0 s.l.x (view s v i)=true ↔ p.afoot s v:= by
   unfold compo at h
   simp [view,afoot,good0,axis,h,road,slipk,loan,faith,and_comm]
lemma abroad {v i} (h:2≤ p.compo s v) :
    p.good0 s.l.x (view s v i)=true ↔
       p.swift s v (p.wherep s v i) ∧ p.label s v i (p.wherep s v i)=i+1 := by
   unfold compo at h; let x:=p.r.mode.f s.l.x (s.q,v)
   change 2 ≤ x at h
   have he:p.r.mode.f s.l.x (s.q,v)≠0:=by change x≠0; omega
   have hk:p.r.mode.f s.l.x (s.q,v)≠1:=by change x≠1; omega
   have hm:¬ p.r.mode.f s.l.x (s.q,v)≤1:=by change ¬ x≤1; omega
   simp [view,wherep,label,good0,road,axis,loan,swift,hm,he,hk,swept,faith,slipk]
   tauto

lemma stamp (b:Bool) {v i} (h:p.compo s v=1) :
    p.road b s.l.x (view s v i)=p.slipk s v:=by simp_all [road,compo,axis,slipk]
lemma stampm (b:Bool) {v i} (h:2≤p.compo s v) :
    p.road b s.l.x (view s v i)=p.swept s v (p.wherep s v i) b := by
   unfold road; exact ite_eq_right (by change ¬ p.compo s v ≤ 1; omega)

lemma approved {v i} :
    p.bud.ready (p.clay s) v i=true ↔
     (v∈(p.clay s).raw ∧ i∈(p.clay s).raw ∧ i < caplen v ^ p.A ∧ v < caplen i ^ p.A) ∧
      p.good0 s.l.x (view s v i)=true:= by
   change (((decide (i < p.total s.l.x s.q) && decide (i < caplen v ^ p.A)) &&
     (decide (v < p.total s.l.x s.q) && decide (v < caplen i ^ p.A))) &&
     p.good0 s.l.x (s.q, v, i)) = true ↔ _
   simp only [Bool.and_eq_true, decide_eq_true_eq, clay, mem_range]
   tauto

namespace Fires
variable {p s}
lemma tilt (h:Fires p s): p.bud.Wall (p.clay s):= by
   let w:=p.O s.l.x s.q
   let v:=p.clay s
   change p.bud.Wall v
   have hc := h.ax; have hw: 1≤ w.w:=h.wp
   refine ⟨fun {a b} hz=>(p.approved s).1 hz|>.1,fun {a c} ha hs i hi b=>?_,fun {a b} hs he dir=>?_,
           fun {a b} hs he x hx dir=>?_, fun {a b} hs he=>?_, ?_⟩
   · change i ≤ caplen a ^p.A at hi
     refine ⟨h.hands _ hs,?_⟩
     replace ha: a<2^(charge p.A w.w w.t) :=
       lt_of_lt_of_le (mem_range.1 ha) (min_le_right ..)
     have hh : lb a≤ charge p.A w.w w.t:=modest ha (by unfold charge; nlinarith)
     have he:lb (enc ((b,a,i):Panel))+1≤(2*p.A+40)*lb a:=p.cheaply hc hi true b
     have hl:=span_mono (show span p.A w.w w.t 0 (lb a) by unfold span charge at *; omega)
                   (D:=p.price) (by unfold price; nlinarith) hc
     have hz:=lax (show span p.A w.w w.t 0 (lb a) by unfold span charge at *; omega) (m:=2*p.A+40)
               (D:=p.price) (by unfold price; nlinarith) hc
     change span p.price w.w w.t 0 (lb (enc ((b,a,i):Panel))+1)
     have hv : p.price*p.A ≤ p.price*p.price:=by unfold price; nlinarith
     unfold span; nlinarith [Nat.mul_le_mul_right w.w hv]
   · let f:=p.road dir s.l.x (view s a b)
     let u:=p.E0 s.l.x f
     obtain ⟨hh,ht⟩:= (p.approved s).1 hs
     change p.compo s a≠0 at he
     have hl: p.faith s a f:=by
        by_cases hx:p.compo s a=1
        · rw [show f=p.slipk s a from p.stamp s dir hx]
          exact ((p.bright s hx).1 ht).2
        have hg:2≤ p.compo s a:=by omega
        rw [show f=p.swept s a (p.wherep s a b) dir from p.stampm s dir hg]
        exact ((p.abroad s hg).1 ht).1.2 dir
     change u.w+v.d≤w.w ∧ span p.A (w.w-u.w) w.t u.t (lb a+1) at hl
     change s.l.jump p.price w v.d (enc ((false,(if dir then (a,b) else (b,a))):Panel)) f
     unfold Lot.jump; rw [h.openL]; change u.w+v.d≤w.w ∧ _
     have hz:= lax hl.2 (m:=2*p.A+40) (D:=p.price) (by unfold price; nlinarith) hc
     have hv : p.price*p.A ≤ p.price*p.price:=by unfold price; nlinarith
     have hh1:= p.cheaply hc hh.2.2.1.le dir false
     refine ⟨hl.1,?_⟩

     change span p.price (w.w-u.w) w.t u.t (lb (enc ((false,Bud.invert dir (a,b)):Panel))+1)
     unfold span; nlinarith [Nat.mul_le_mul_right (w.w-u.w) hv]
   · change p.compo s a=1 at he
     have hl:= (p.bright s he).1 ((p.approved s).1 hs).2
     have hs := h.ring (p.slipk s a) hl.1 ⟨_,hl.2⟩ x hx
     change Boots s.l.x s.l.F s.l.P (p.road dir s.l.x (view s a b)) _ _ _
     rw [p.stamp s dir he]
     exact hs
   · change 2 ≤ p.compo s a at he
     have hp:= (p.abroad s he).1 ((p.approved s).1 hs).2
     refine ⟨hp.2,fun x hx dir=>?_⟩
     have hy:=h.rout _ _ hp.1.1 (fun b=> ⟨_,hp.1.2 b⟩) x hx dir
     refine ⟨?_,hy.2⟩
     change Boots s.l.x _ _ (p.road dir s.l.x (view s a b)) _ _ _
     rw [p.stampm s dir he]; exact hy.1
   · intro v i j _ _ _ x _ y z g e
     exact h.uniq g e
end Fires

end Mill
end ExactDerandomization.Mint

end

section

namespace ExactDerandomization.Mint
open Relay Swirl Finset
namespace Mill
variable (p:Mill) (s:Fuel)
abbrev prize := charge p.A (p.O s.l.x s.q).w (p.O s.l.x s.q).t
def Reserve := 2^prize p s ≤ p.v.storeU.f s.l.x s.q
def fitting (x y:ℕ) := lb x≤ prize p s ∧ lb y≤prize p s ∧
                           lb x ≤ lb y*p.A ∧ lb y ≤ lb x*p.A
abbrev minted:=p.bud.Hill (p.clay s)
lemma mem_of {x} (h:p.Reserve s) (he:lb x≤prize p s) : x∈(p.clay s).raw :=
   mem_range.2 ((below x).trans_le (by
      change (2:ℕ)^(lb x)≤ min _ (2^prize p s)
      rw [min_eq_right h]; exact Nat.pow_le_pow_right Nat.zero_lt_two he))

lemma bid {x y} (h:p.Reserve s) (he:fitting p s x y) (hh:p.good0 s.l.x (view s x y)=true):
   p.bud.ready (p.clay s) x y=true := by
    apply (approved _ _).2
    have hc {x y} (h:lb x≤lb y*p.A): x < caplen y^p.A :=
       (below x).trans_le (by unfold caplen; rw [← pow_mul]; exact Nat.pow_le_pow_right Nat.zero_lt_two h)
    exact ⟨⟨p.mem_of s h he.1,p.mem_of s h he.2.1,hc he.2.2.2,hc he.2.2.1⟩,hh⟩

lemma meets0 {v i x} (h:p.Reserve s) (he:fitting p s v i) (hh:p.compo s v=0)
    (hk:p.label s v i 0=i+1) (hx:x∈s.domain) : minted p s (v,x) (i,x):=
   ⟨(Bud.walled _).2 ⟨p.mem_of s h he.1,hx⟩,(Bud.walled _).2 ⟨p.mem_of s h he.2.1,hx⟩,
        p.bid s h he (p.purity s hh),by
          change (match p.compo s v with | 0=>_ | 1=>_ | _=>_)
          rw [hh]; exact ⟨hk,rfl⟩⟩
lemma meets1 {v i x} (h:p.Reserve s) (he:fitting p s v i) (hh:p.compo s v=1)
    (hk:p.label s v i (s.echo (p.slipk s v) x)=i+1) (hz:p.afoot s v)
    (hx:x∈s.domain) : minted p s (v,x) (i,x):=
   ⟨(Bud.walled _).2 ⟨p.mem_of s h he.1,hx⟩,(Bud.walled _).2 ⟨p.mem_of s h he.2.1,hx⟩,
        p.bid s h he ((bright p s hh).2 hz),by
          change (match p.compo s v with | 0=>_ | 1=>_ | _=>_)
          rw [hh]; exact ⟨hk,rfl⟩⟩
lemma meets2 {v i x y b} (h:p.Reserve s) (he:fitting p s v i) (hh:p.compo s v=2)
    (hz:b=p.wherep s v i) (hk:p.label s v i b=i+1) (hf:p.swift s v b)
    (hx:x∈s.domain) (hy:y∈s.domain) (hr:s.stream (p.slipk s v) b true x=some y) :
    minted p s (v,x) (i,y):=by
   subst b
   exact ⟨(Bud.walled _).2 ⟨p.mem_of s h he.1,hx⟩,(Bud.walled _).2 ⟨p.mem_of s h he.2.1,hy⟩,
        p.bid s h he ((abroad p s (by change 2 ≤ p.compo s v; omega)).2 ⟨hf,hk⟩),by
          change (match p.compo s v with | 0=>_ | 1=>_ | _=>_)
          rw [hh]; exact hr⟩

abbrev mate (v:Dot) := ∀ y,¬ p.minted s v y
lemma cinder0 {v c} (h:p.compo s v=0) (hh:∀ i,p.label s v i 0=0) : p.mate s (v,c) := by
   rintro ⟨i,y⟩ ⟨-,hz,_,e⟩
   change (match p.compo s v with| 0=> _| 1=>_|_=>_) at e
   rw [h] at e; have hp:p.label s v i 0=i+1:= e.1; rw [hh] at hp; omega
lemma cinder1 {v c} (h:p.compo s v=1) (hh:∀ i,p.label s v i (s.echo (p.slipk s v) c)=0) :
   p.mate s (v,c) := by
   rintro ⟨i,y⟩ ⟨-,hz,_,e⟩
   change (match p.compo s v with| 0=> _| 1=>_|_=>_) at e
   rw [h] at e; have hp:p.label s v i (s.echo (p.slipk s v) c)=i+1:= e.1; rw [hh] at hp; omega
end Mill
end ExactDerandomization.Mint

end

end OAI