lean/OAI/Computability/Logspace/RecursivePrograms.lean

import OAI.Computability.Logspace.CounterPrograms

namespace OAI

/-!
Measured stack encodings and the realization of recursive programs with simultaneous space bounds.

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

set_option autoImplicit true

section

/-! Measured encodings. `cord` appends with overhead on just the new
piece, not the previously suspended stack. -/
namespace ExactDerandomization.Relay
open Counter

def lb (x : ℕ) := x.log2+1

lemma lb_pos (x) : 0<lb x := by dsimp [lb]; omega
lemma lb_zero : lb 0=1 := rfl
lemma lb_one : lb 1=1 := rfl
lemma below (x) : x < 2^lb x := Nat.lt_log2_self
lemma above {x:ℕ} (h:0<x) : 2^(lb x)  ≤  2*x := by
   unfold lb; rw [pow_succ]
   have he : 2^x.log2 ≤ x := Nat.log2_self_le (by omega)
   omega
lemma modest {x k : ℕ} (h:x < 2^k) (e:1 ≤ k) : lb x ≤ k := by
   by_cases hx : x=0
   · simpa [hx,lb_zero]
   by_contra! hh
   have he : lb x ≥ k+1 := by omega
   have ht := le_trans (Nat.pow_le_pow_right (Nat.zero_lt_two) he) (above (x:=x) (by omega))
   rw [pow_succ] at ht
   omega
lemma growing (x : ℕ) : x+1 ≤ 2^x := by
   induction x with
   | zero=> simp
   | succ x ih=> rw [pow_succ]; omega
lemma lb_le_inc (x : ℕ) : lb x ≤ x+1 :=
    modest (lt_of_lt_of_le (show x < (x+1)+1 by omega) (growing _)) (by omega)
lemma lb_mono {x y} (h:x ≤ y) : lb x ≤ lb y:=
   modest (h.trans_lt (below _)) (lb_pos y)
lemma lb_succ (x) : lb (x+1)  ≤  lb x+1 :=
   modest (by have:= below x; rw [pow_succ]; omega) (by omega)
lemma lb_plus (x y) : lb (x+y) ≤ max (lb x) (lb y)+1 := by
   apply modest _ (by omega)
   have xx := (below x).trans_le (Nat.pow_le_pow_right Nat.zero_lt_two (le_max_left (lb x) (lb y)))
   have yy := (below y).trans_le (Nat.pow_le_pow_right Nat.zero_lt_two (le_max_right (lb x) (lb y)))
   rw [pow_succ]; omega
lemma lb_times (x y) : lb (x*y)  ≤ lb x+lb y :=
    modest (by rw [pow_add]; exact Nat.mul_lt_mul_of_lt_of_lt (below x) (below y))
         ((lb_pos x).trans_le (by omega))
lemma lb_shift (x) : lb (2^x)=x+1 := by
   apply le_antisymm
   · have ht : 0<(2:ℕ)^x := by positivity
     exact modest (by rw [pow_succ]; omega) (by omega)
   by_contra! he
   have hs:=Nat.pow_le_pow_right (n:=2) Nat.zero_lt_two (show lb (2^x) ≤ x by omega)
   have he:=below (2^x); omega

def cord (a s : ℕ) : ℕ := 2^(lb a) * (1+ 2*a +2^(lb a+1)*s)

lemma cord_bounds (a s : ℕ) (hs : 1  ≤  s) :
   2 ^ (lb s-1+(2*lb a+1))  ≤  cord a s ∧ cord a s<2^(lb s+ (2*lb a+1)) := by
   let k:=lb a
   have he1 := (below a)
   have he2 := (below s)
   have he3 : 2^(lb s-1) ≤ s := by
      simp only [lb, Nat.add_sub_cancel]
      exact Nat.log2_self_le (by omega)
   have he4 (i) : 2^(i+(2*k+1)) = 2^k*(2^(k+1)* (2:ℕ)^i) := by
      rw [show i+(2*k+1)=k+((k+1)+i) by omega,pow_add,pow_add]
   change 2^(lb s-1+ (2*k+1))  ≤  2^k*(1+2*a+2^(k+1)*s) ∧
        2^k*(1+2*a+2^(k+1)*s) < 2^(lb s+(2*k+1))
   simp only [he4]
   constructor
   · exact Nat.mul_le_mul_left _ ((Nat.mul_le_mul_left (2^(k+1)) he3).trans (by omega))
   apply Nat.mul_lt_mul_of_pos_left _ (by positivity)
   have he := Nat.mul_le_mul_left (2^(k+1)) (show s+1  ≤  2^(lb s) from he2)
   change a < 2^k at he1
   nlinarith [pow_succ (2:ℕ) k]

lemma lb_cord (a s : ℕ) (hs : 1  ≤  s) :
   lb (cord a s)=lb s+(2*lb a+1) := by
  obtain ⟨ha,hb⟩:=cord_bounds a s hs
  apply le_antisymm (modest hb (by omega))
  by_contra! h
  have h1:=lb_pos s
  have h2:=Nat.pow_le_pow_right (n:=2) Nat.zero_lt_two
          (show lb (cord a s)  ≤  lb s-1+(2*lb a+1) by omega)
  have he:=below (cord a s)
  omega

lemma cord_fine (a s : ℕ) : s< cord a s ∧ a<cord a s ∧ 1 < cord a s := by
   have h : 2  ≤  2^(lb a):=by
      simpa using Nat.pow_le_pow_right (n:=2) Nat.zero_lt_two (lb_pos a)
   unfold cord; rw [pow_succ]
   have he := Nat.mul_le_mul_right (1+ 2*a +2^lb a*2*s) h
   have hz := Nat.mul_le_mul_right s h
   refine ⟨?_,?_,?_⟩ <;> nlinarith

def discover (x : ℕ) (k : ℕ) : ℕ :=
   forNat (fun j t=> if x % (min (x+1) (2^(j+1)))=0 then j+1 else t) 0 k

def pierce (x : ℕ) := discover x x
def wing (x : ℕ) := min (x+1) (2^pierce x)
def middle (x : ℕ) := x/ wing x /2
def fore (x) := middle x % wing x
def aft (x) := middle x / wing x

lemma pierce_rule (a s : ℕ) : pierce (cord a s)=lb a := by
   let k:=lb a
   let n:=2^k
   let x:=cord a s
   let w:=a+n*s
   have hn : 0<n := by dsimp [n]; positivity
   have hx : x = n*(1+2*w) := by simp only [x,w,n,k,cord,pow_succ]; ring
   have hh : n  ≤  x := by nlinarith
   have hp (j : ℕ) : x%min (x+1) (2^j)=0 ↔ j ≤ k := by
      by_cases hg : j ≤ k
      · have he : 2^j ∣ x := (pow_dvd_pow _ hg).trans (hx ▸ ⟨_,rfl⟩)
        have ht : 2^j  ≤  x+1 := by
           have h2 : 2^j ≤ n := Nat.pow_le_pow_right Nat.zero_lt_two hg; omega
        simp [hg,ht,Nat.mod_eq_zero_of_dvd he]
      by_cases ho : 2^j  ≤  x+1
      · rw [min_eq_right ho]; refine ⟨fun he=>?_,fun e=>by omega⟩
        have he1:= (pow_dvd_pow 2 (show k+1 ≤ j by omega)).trans (Nat.dvd_of_mod_eq_zero he)
        rw [pow_succ,hx] at he1
        obtain ⟨b,hb⟩:=he1
        change n*(1+2*w)=n*2*b at hb
        rw [mul_assoc] at hb
        have ht := Nat.eq_of_mul_eq_mul_left hn hb
        omega
      rw [min_eq_left (by omega),Nat.mod_eq_of_lt (by omega)]; omega
   have hi (j) : discover x j=min j k := by
      induction j with
      | zero=> simp [discover,forNat]
      | succ j ih=>
         change (if _ then _ else discover x j)=_
         rw [ih]; simp only [hp]
         by_cases he:j+1 ≤ k
         · simp [he]
         have ht:k≤j:=by omega
         simp [he,ht,le_trans ht (show j ≤ j+1 by omega)]
   have hv:=growing k
   change k+1 ≤ n at hv
   exact (hi x).trans (by omega)

@[simp] lemma wing_cord (a s) : wing (cord a s)=2^lb a := by
   rw [wing,pierce_rule, min_eq_right]
   unfold cord
   apply le_trans (show _ ≤ 2^lb a*(1+2*a+ 2^(lb a+1)*s) from ?_) (by omega)
   exact Nat.le_mul_of_pos_right _ (by omega)

lemma middle_cord (a s) : middle (cord a s)=a+2^(lb a)*s := by
   rw [middle,wing_cord,cord,pow_succ]
   rw [Nat.mul_div_cancel_left _ (by positivity)]
   have he : 1+2*a+2^(lb a)*2*s=1+(a+2^(lb a)*s)*2 :=by ring
   rw [he,Nat.add_mul_div_right _ _ (by omega)]
   simp

@[simp] lemma fore_cord (a s) : fore (cord a s)=a := by simp [fore,middle_cord,Nat.mod_eq_of_lt (below a)]
@[simp] lemma aft_cord (a s) : aft (cord a s)=s := by
   rw [aft,middle_cord,wing_cord,Nat.add_mul_div_left _ _ (by positivity),Nat.div_eq_of_lt (below a),
       zero_add]

def bead (a b : ℕ) : ℕ := cord a (b+1)
def heed (n : ℕ) := fore n
def readt (n : ℕ) := aft n-1

@[simp] lemma heed_eq (a b) : heed (bead a b)=a := by simp [heed,bead]
@[simp] lemma read_eq (a b) : readt (bead a b)=b := by simp [readt,bead]

lemma bead_small (a b) : lb (bead a b)  ≤  2*lb a + lb b +2 := by
   rw [bead,lb_cord _ _ (by omega)]
   have:= lb_succ b; omega

end ExactDerandomization.Relay

end

section

namespace ExactDerandomization.Relay
open Counter

def hunt (x k : ℕ) := forNat (fun j a=> if min (x+1) (2^(j+1)) ≤ x then j+1 else a) 0 k

lemma under_pow (x j : ℕ) :
    min (x+1) (2^(j+1)) ≤ x ↔ j+1 ≤ x.log2 := by
   by_cases h:x=0
   · subst x
     have hs : 1 ≤ (2:ℕ)^(j+1) := Nat.one_le_pow _ _ (by omega)
     simp [hs]
   have hs : 2^x.log2 ≤ x := Nat.log2_self_le h
   have he := below x
   unfold lb at he
   constructor
   · intro hf; have hl : 2^(j+1) ≤ x:=by omega
     by_contra! hm
     have hg := (Nat.pow_le_pow_right (n:=2) Nat.zero_lt_two (show x.log2+1 ≤ j+1 by omega))
     omega
   intro hh
   have hl : 2^(j+1) ≤ x := le_trans (Nat.pow_le_pow_right Nat.zero_lt_two hh) hs
   omega

lemma found (x k) : hunt x k=min k x.log2 := by
   induction k with
   | zero=> simp [hunt,forNat]
   | succ k ih=>
     change (if _ then _ else hunt x k)=_
     rw [ih]; simp only [under_pow]
     by_cases h:k+1≤x.log2
     · simp [h]
     have he : x.log2≤ k := by omega
     simp [h,he,show x.log2≤ k+1 by omega]

variable {f g : NE}

/-- E calculation of a "current or small index" loop -/
lemma run_huntE (f : NE) (p : ℕ→ℕ→Prop) [(x y : ℕ) → Decidable (p x y)]
    (hp : ∀ {g j:NE}, E g → E j → Counter.Pick (fun x a => decide (p (g x a) (j x a))))
    (h : E f) :
    E (fun x a => forNat
         (fun j v=> if p (f x a) j then j+1 else v) 0 (f x a)) := by
   apply E.iterate (fun x a j v=> if p (f x a) j then j+1 else v) f (fun _ _=>0)
   · intro g j hg he
     simpa only [decide_eq_true_eq] using (hp h hg).ite hg.succ he
   · exact h
   · exact E.const 0
   · obtain ⟨k,h⟩:=h.1; exact ⟨k,fun x a b e=>by rw [h x a b e]⟩
   obtain ⟨d,hp,he⟩:=h.bound
   refine ⟨d,hp,fun x a B hb hs j hj=>?_⟩
   have hl (j) : forNat (fun j v=> if p (f x a) j then j+1 else v) 0 j ≤ j := by
      induction j <;> simp only [forNat]
      · exact le_rfl
      split <;> omega
   exact lt_of_le_of_lt (le_trans (hl j) hj) (he _ _ _ hb hs)

lemma log2E (h:E f) : E (fun x a=> (f x a).log2) := by
   have he (n) : hunt n n=n.log2 := (found n n).trans
     (min_eq_right (by have he:=lb_le_inc n; unfold lb at he; omega))
   simp_rw [← he]
   apply run_huntE _ (fun x j=> min (x+1) (2^(j+1)) ≤ x) _ h
   intro x j hx hj
   have hr := E.capPow (E.const 2) hj.succ hx.succ

   convert Pick.test_eq (hr.sub hx) (E.const 0) using 1
   ext x a
   simp
   omega

lemma lbE (h:E f) : E (fun x a=> lb (f x a)) := (log2E h).succ
lemma digitsE (h:E f) : E (fun x a=> 2^lb (f x a)) := by
   have he(n) : min (2*(n+1)) (2^lb n)=2^lb n := by
      apply min_eq_right
      by_cases h:n=0
      · subst n; simp [lb_zero]
      have he:=above (x:=n) (by omega); omega
   simpa only [he] using E.capPow (E.const 2) (lbE h) ((E.const 2).mul h.succ)

lemma cordE (h:E f) (e:E g) : E (fun x a=> cord (f x a) (g x a)) := by
   unfold cord; simp_rw [pow_succ]
   have ht:=digitsE h
   exact ht.mul (((E.const 1).add ((E.const 2).mul h)).add ((ht.mul (E.const 2)).mul e))
lemma pierceE (h:E f) : E (fun x a=> pierce (f x a)) := by
   apply run_huntE _ (fun x j=> x%min (x+1) (2^(j+1))=0) _ h
   intro x j hx hj
   exact Pick.test_eq (hx.mod (E.capPow (E.const 2) hj.succ hx.succ)) (E.const 0)
lemma wingE (h:E f) : E (fun x a=> wing (f x a)) :=
   E.capPow (E.const 2) (pierceE h) h.succ
lemma middleE (h:E f) : E (fun x a=> middle (f x a)) := (h.div (wingE h)).div (E.const 2)
lemma foreE (h:E f) : E (fun x a=> fore (f x a)) := (middleE h).mod (wingE h)
lemma aftE (h:E f) : E (fun x a=> aft (f x a)) := (middleE h).div (wingE h)

def Uni (f : Word → ℕ → ℕ) := ∀ ⦃g : NE⦄,E g → E fun x a=> f x (g x a)

class Wire (α:Type) where
    enc : α→ℕ
    dec : ℕ→α
    eq : ∀ a,dec (enc a)=a
    tidy : Uni (fun _ i=>enc (dec i))

export Wire (enc dec)

abbrev measure {α} [Wire α] (a : α) := lb (enc a)

instance : Wire ℕ := ⟨id,id,fun _=>rfl,fun _ h=>h⟩
lemma enc_nat (n:ℕ) : enc n=n := rfl

instance {α β} [Wire α] [Wire β] : Wire (α×β) where
   enc p:= bead (enc p.1) (enc p.2)
   dec i:= (dec (heed i),dec (readt i))
   eq p:= by simp [Wire.eq]
   tidy:= by
     intro g h
     have he:= @Wire.tidy α _
     have ht:= @Wire.tidy β _
     exact cordE (he (foreE h)) (ht (aftE h).pred).succ

instance : Wire Bool where
   enc p:= if p then 1 else 0
   dec i:= decide (1 ≤ i)
   eq p:= by cases p <;> simp
   tidy:= by
     intro g h
     have hg:= E.ite_le (E.const 1) h (E.const 1) (E.const 0)
     simpa only [decide_eq_true_eq] using hg

@[simp] lemma dec_round {α} [Wire α] (a : α) : dec (enc a)=a := Wire.eq a
lemma measure_pair {α β} [Wire α] [Wire β] (a : α) (b:β) :
    measure (a,b) ≤2*measure a+measure b+2:=bead_small _ _

/-- Pointwise semantic LF functions requiring only wire encodings. -/
abbrev PT (α β : Type) := Word→α→β

def Kn {α β : Type} [Wire α] [Wire β] (f : PT α β) := Uni fun x a => enc (f x (dec a))

namespace Kn
variable {α β γ δ : Type} [Wire α] [Wire β] [Wire γ] [Wire δ]

lemma identity : Kn (fun (_:Word) (x:α)=>x) := Wire.tidy

lemma comp {f:PT α β} {g:PT β γ} (h:Kn g) (e:Kn f) :
   Kn (fun x a=> g x (f x a)) := by
   intro v hv
   simpa only [Wire.eq] using h (e hv)
lemma tuple {f:PT α β} {g:PT α γ} (h:Kn f) (k:Kn g) :
   Kn (fun x a=> (f x a,g x a)) := by
   intro v hv
   exact cordE (h hv) (k hv).succ
lemma first : Kn (fun (_:Word) (x:α×β)=> x.1) := by
   intro g h
   exact @Wire.tidy α _ _ (foreE h)
lemma next : Kn (fun (_:Word) (x:α×β)=> x.2) := by
   intro g h
   exact @Wire.tidy β _ _ (aftE h).pred
lemma left {f:PT α (β×γ)} (h:Kn f) : Kn (fun x a=> (f x a).1) := first.comp h
lemma right {f:PT α (β×γ)} (h:Kn f) : Kn (fun x a=> (f x a).2) := next.comp h
lemma wash : Kn (fun (_:Word) (x:α)=>enc x):= Wire.tidy
lemma unpack : Kn (fun (_:Word) (x:ℕ)=> (dec x:α)):= Wire.tidy
lemma fix (b:β) : Kn (fun (_:Word) (_:α)=>b):= fun _ _=> E.const _
lemma word (b : Word→β) (h:E (fun x _=>enc (b x))) :
    Kn (fun (x:Word) (_:α)=>b x) := fun _ _=>h

variable {f g t w : PT α ℕ}

lemma add (h:Kn f) (e:Kn g) : Kn (fun x a=> f x a+g x a):=fun _ u=>(h u).add (e u)
lemma sub (h:Kn f) (e:Kn g) : Kn (fun x a=> f x a-g x a):=fun _ u=>(h u).sub (e u)
lemma times (h:Kn f) (e:Kn g) : Kn (fun x a=> f x a*g x a):=fun _ u=>(h u).mul (e u)
lemma div (h:Kn f) (e:Kn g) : Kn (fun x a=> f x a/g x a):=fun _ u=>(h u).div (e u)
lemma mod (h:Kn f) (e:Kn g) : Kn (fun x a=> f x a%g x a):=fun _ u=>(h u).mod (e u)
lemma power (d:ℕ) (h:Kn f) : Kn (fun x a=> (f x a)^d) := fun _ u=>E.pow_const (h u) d
lemma succ (h:Kn f) : Kn (fun x a=> f x a+1):=h.add (fix (α:=α) (1:ℕ))
lemma pred (h:Kn f) : Kn (fun x a=> f x a-1):=h.sub (fix (α:=α) (1:ℕ))

lemma cond {f g:PT α β} {s:PT α Bool} (hs:Kn s) (h:Kn f) (e:Kn g) :
    Kn (fun x a=> if s x a then f x a else g x a) := by
   intro u hu
   convert (hs hu).ite (e hu) (h hu) using 1
   ext x a; cases hv:s x (dec (u x a)) <;> simp [Wire.enc,hv]

lemma le (h:Kn f) (e:Kn g) : Kn (fun x a=> decide (f x a ≤ g x a)) := by
   intro u hu
   have ht:= (h hu).ite_le (e hu) (E.const 1) (E.const 0)
   convert ht using 1; ext x a; simp [Wire.enc]
lemma lt (h:Kn f) (e:Kn g) : Kn (fun x a=> decide (f x a < g x a)) :=
   h.succ.le e
lemma eq (h:Kn f) (e:Kn g) : Kn (fun x a=> decide (f x a=g x a)) := by
   intro u hu
   have ht:= (h hu).ite_eq (e hu) (E.const 1) (E.const 0)
   convert ht using 1; ext x a; simp [Wire.enc]
lemma cond_le (h:Kn f) (e:Kn g) {u v:PT α β} (hu:Kn u) (hv:Kn v) :
    Kn (fun x a=> if f x a ≤ g x a then u x a else v x a) := by
   simpa only [decide_eq_true_eq] using (h.le e).cond hu hv
lemma cond_lt (h:Kn f) (e:Kn g) {u v:PT α β} (hu:Kn u) (hv:Kn v) :
    Kn (fun x a=> if f x a < g x a then u x a else v x a) := by
   simpa only [decide_eq_true_eq] using (h.lt e).cond hu hv
lemma cond_eq (h:Kn f) (e:Kn g) {u v:PT α β} (hu:Kn u) (hv:Kn v) :
    Kn (fun x a=> if f x a=g x a then u x a else v x a) := by
   simpa only [decide_eq_true_eq] using (h.eq e).cond hu hv
lemma cap (h:Kn t) (k:Kn f) (u:Kn g) :
    Kn (fun x a=> min (t x a) ((f x a)^(g x a))) :=
   fun _ e=>E.capPow (k e) (u e) (h e)
lemma small (h:Kn f) (k:Kn g) : Kn (fun x a=> min (f x a) (g x a)) :=
    fun _ e=>E.minE (h e) (k e)
lemma bl (h:Kn f) : Kn (fun x a=> lb (f x a)) := fun _ e=>lbE (h e)

lemma push (h:Kn f) (k:Kn g) :
    Kn (fun x a=> cord (f x a) (g x a)):= fun _ e=>cordE (h e) (k e)
lemma top (h:Kn f) :
    Kn (fun x a=> fore (f x a)):= fun _ e=>foreE (h e)
lemma tail (h:Kn f) :
    Kn (fun x a=> aft (f x a)):= fun _ e=>aftE (h e)

/-- LF state loops with a uniform numeric ceiling given by another LF expression -/
lemma stroll (step : PT (α×ℕ×ℕ) ℕ)
    (n z limit : PT α ℕ)
    (h : Kn step) (hn:Kn n) (hz:Kn z) (he:Kn limit)
    (hp : ∀ x a,∀ j≤ n x a, forNat (fun k v=>step x (a,k,v)) (z x a) j ≤ limit x a) :
    Kn (fun x a=> forNat (fun k v=> step x (a,k,v)) (z x a) (n x a)) := by
   intro g hg
   let f (x : Word) (a : Store) (j v: ℕ) := step x ((dec (g x a):α), j, v)
   apply E.iterate f (fun x a=> n x (dec (g x a))) (fun x a=> z x (dec (g x a)))
   · intro j v hj hv
     have eu : E (fun x a=> enc ((dec (g x a):α), j x a, v x a)) :=
       cordE (@Wire.tidy α _ _ hg) (cordE hj hv.succ).succ
     simpa only [Wire.eq,enc_nat,f] using h eu
   · exact hn hg
   · exact hz hg
   · obtain ⟨k,h⟩:=hg.1; exact ⟨k,fun x a b e=>by simp only [f,h x a b e]⟩
   obtain ⟨d,hd,h⟩:=(he hg).bound
   exact ⟨d,hd,fun x a B e u j v => lt_of_le_of_lt (hp x (dec (g x a)) j v) (h x a B e u)⟩

end Kn
end ExactDerandomization.Relay

end

section

namespace ExactDerandomization.Relay
open Counter

lemma cord_mono {a b c d} (h:a≤b) (e:c≤d) : cord a c≤cord b d := by
   have ht:=lb_mono h
   unfold cord; gcongr
lemma bead_mono {a b c d} (h:a≤b) (e:c≤d) : bead a c≤bead b d := cord_mono h (by omega)
lemma pair_mono {a b c d : ℕ} (h:a≤b) (e:c≤d) : enc (a,c)≤enc (b,d):=bead_mono h e

lemma Kn.fold {α β : Type} [Wire α] [Wire β] (step : PT (α× ℕ×β) β)
    (z : PT α β) (n lim : PT α ℕ)
    (hf: Kn step) (hz:Kn z) (ht:Kn n) (he: Kn lim)
    (hh : ∀ x a,∀ j≤ n x a, enc (forNat (fun k v=>step x (a,k,v)) (z x a) j) ≤ lim x a) :
    Kn (fun x a=> forNat (fun k v=>step x (a,k,v)) (z x a) (n x a)) := by
   let f : PT (α×ℕ×ℕ) ℕ := fun x u=> enc (step x (u.1,u.2.1,dec u.2.2))
   have hu(x a j) :
       forNat (fun k v=>f x (a,k,v)) (enc (z x a)) j= enc
           (forNat (fun k v=>step x (a,k,v)) (z x a) j) := by
     induction j <;> simp_all [forNat,f]
   have hn : Kn f := wash.comp (hf.comp
          (first.tuple (next.left.tuple (unpack.comp next.right))))
   have h:= stroll f _ _ _ hn ht (wash.comp hz) he (fun x a j hv=>by rw [hu]; exact hh x a j hv)
   simpa only [hu,Wire.eq] using (unpack (α:=β)).comp h

def mesh : List ℕ → ℕ
   | []=>1
   | a::b=>cord a (mesh b)
lemma mesh_length (l) : l.length < mesh l:=by
    induction l with
    | nil=>simp [mesh]
    | cons a l ih=> exact lt_of_le_of_lt ih (cord_fine a (mesh l)).1
lemma mesh_pos (l) : 1≤ mesh l:= (Nat.zero_le _).trans_lt (mesh_length l)
lemma measure_mesh (a l) : lb (mesh (a::l))=lb (mesh l)+(2*lb a+1) :=
    lb_cord _ _ (mesh_pos l)

lemma mesh_append (l r) : lb (mesh (l++r))+1=lb (mesh l)+lb (mesh r) := by
   induction l with
   | nil=> simp [mesh,lb_one,Nat.add_comm]
   | cons v l ih=>
     simp only [List.cons_append,measure_mesh]
     omega
lemma mesh_reverse (l) : lb (mesh l.reverse)=lb (mesh l) := by
   induction l with
   | nil=> simp
   | cons a l ih=>
     rw [List.reverse_cons,measure_mesh]
     have ht:=mesh_append l.reverse [a]; rw [measure_mesh,ih] at ht
     change _+1=lb (mesh l)+(lb 1+_) at ht; rw [lb_one] at ht
     omega

def ebb {α} (f:PT (α×ℕ×ℕ) ℕ) (x : Word) (a : α) (lim load : ℕ) (v:ℕ×ℕ) : ℕ×ℕ :=
   if v.1≤1 then v else (min load (aft v.1),min lim (f x (a,fore v.1,v.2)))
def sweep {α} (f:PT (α×ℕ×ℕ) ℕ) (r z lim : PT α ℕ) : PT α ℕ :=
   fun x a=>
   (forNat (fun _ v=>ebb f x a (lim x a) (r x a) v)
      (r x a,min (lim x a) (z x a)) (r x a)).2

lemma Kn.sweepK {α : Type} [Wire α] (f:PT (α×ℕ×ℕ) ℕ) (r z lim : PT α ℕ)
   (hf:Kn f) (hr:Kn r) (hz:Kn z) (h:Kn lim) : Kn (sweep f r z lim) := by
   let step : PT (α×ℕ×(ℕ×ℕ)) (ℕ×ℕ) := fun x a=> ebb f x a.1 (lim x a.1) (r x a.1) a.2.2
   let src : PT α (ℕ×ℕ) := fun x a=>(r x a,min (lim x a) (z x a))
   have hv : Kn step := by
     have h1 : Kn (fun (_:Word) (a:α×ℕ×(ℕ×ℕ))=> a.1):=first
     have ht : Kn (fun (_:Word) (a:α×ℕ×(ℕ×ℕ))=> a.2.2):=next.right
     exact ht.left.cond_le (fix 1) ht (((hr.comp h1).small ht.left.tail).tuple
       ((h.comp h1).small (hf.comp (h1.tuple (ht.left.top.tuple ht.right)))))
   have hh : Kn src := hr.tuple (h.small hz)
   have he : Kn (fun x a=>enc ((r x a),(lim x a))) := wash.comp (hr.tuple h)
   apply right (fold step src r _ hv hh hr he ?_)
   intro x a j _
   let p:= forNat (fun k v=>step x (a,k,v)) (src x a)
   have h1 (j) : (p j).1 ≤ r x a ∧ (p j).2≤ lim x a := by
     induction j with
     | zero=> exact ⟨le_rfl,min_le_left ..⟩
     | succ j ih=>
       change (ebb _ _ _ _ _ (p j)).1 ≤ _ ∧ (ebb _ _ _ _ _ (p j)).2 ≤ _
       unfold ebb; split
       · exact ih
       · exact ⟨min_le_left ..,min_le_left ..⟩
   exact pair_mono (h1 j).1 (h1 j).2

inductive Scan (lim:ℕ) (g:ℕ→ℕ→ℕ) : ℕ→List ℕ→ℕ→Prop
   | nil {x} (h:x≤lim) : Scan lim g x [] x
   | cons {x a l y} (h:x≤lim) (e:Scan lim g (g a x) l y) : Scan lim g x (a::l) y
lemma Scan.start {l g a v y} (h:Scan l g a v y) : a≤l := by cases h <;> assumption

lemma forNat_cons {α} (f:α→α) (x : α) (n : ℕ) :
    forNat (fun _=>f) x (n+1)=forNat (fun _=>f) (f x) n := by
   induction n with
   | zero=> rfl
   | succ n ih=>
     rw [forNat,ih]
     rfl

lemma exact_ebb {α} {f:PT (α×ℕ×ℕ) ℕ} {x lim load l a y z}
   (h:Scan lim (fun v w=> f x (a,v,w)) z l y) (e:mesh l≤load) (n:ℕ) (hh:l.length≤ n) :
   forNat (fun _ v=>ebb f x a lim load v) (mesh l,z) n=(1,y) := by
   induction h generalizing n with
   | @nil z h=>
     induction n with
     | zero=> rfl
     | succ n ih=>
       simp only [forNat,ih (by simp)]
       simp [ebb]
   | @cons u v l y h g ih=>
     cases n with
     | zero=> simp at hh
     | succ n=>
       let a0:=mesh (v::l)
       change mesh (v::l)≤ load at e
       have he := cord_fine v (mesh l)
       have ht : ¬mesh (v::l) ≤ 1 := not_le_of_gt he.2.2
       have hh1 : mesh l≤load := he.1.le.trans e
       rw [forNat_cons]
       change forNat _ (ebb f x a lim load (mesh (v::l),u)) n=_
       change ¬cord v (mesh l) ≤ 1 at ht
       unfold ebb; simp only [ht,mesh, ↓reduceIte,fore_cord,aft_cord,min_eq_right hh1,min_eq_right g.start]
       exact ih hh1 n (by simpa using hh)

lemma exact_sweep {α} {f : PT (α×ℕ×ℕ) ℕ} {r z lim : PT α ℕ} {x a l y}
    (h:Scan (lim x a) (fun i j=> f x (a,i,j)) (z x a) l y)
    (e:r x a=mesh l) :
   sweep f r z lim x a=y := by
   unfold sweep; rw [e,min_eq_right h.start]
   rw [exact_ebb h le_rfl _ (mesh_length _).le]

def caplen (n:ℕ) := 2^lb n
def windback (_:Word) (n:ℕ) :=
    sweep (fun _ (i : ℕ×ℕ×ℕ) => cord i.2.1 i.2.2)
      (fun _ k=>k) (fun _ _=>1) (fun _ k=>caplen k) [] n

lemma Kn.caplenK : Kn (fun (_:Word) (n:ℕ)=>caplen n) := fun _ h=>digitsE h
lemma Kn.windbackK : Kn windback :=
   sweepK _ _ _ _ (next.left.push next.right) identity (fix 1) caplenK

lemma backscan (l r:List ℕ) (lim) (h:2^lb (mesh (l++r)) ≤ lim) :
    Scan lim cord (mesh r) l (mesh (l.reverse++r)) := by
   induction l generalizing r with
   | nil=>
     simp only [List.nil_append,List.reverse_nil]
     exact .nil ((below _).le.trans (by simpa using h))
   | cons a l ih=>
     have he r : lb (mesh l)+lb (mesh r)=lb (mesh (l++r))+1 := (mesh_append l r).symm
     have hs : List.reverse (a::l)++r=l.reverse++(a::r) :=by simp
     have hu : lb (mesh r) ≤ lb (mesh ((a::l)++r)) := by
       simp only [List.cons_append,measure_mesh]
       have := he r; have h1:=lb_pos (mesh l); omega
     rw [hs]
     apply Scan.cons ((below (mesh r)).le.trans ((Nat.pow_le_pow_right Nat.zero_lt_two hu).trans h))
     apply ih (a::r)
     have hw : lb (mesh (l++a::r))=lb (mesh ((a::l)++r)) := by
        have h1:=he (a::r)
        rw [measure_mesh] at h1
        simp only [List.cons_append,measure_mesh]
        have := he r; omega
     rw [hw]; exact h

lemma windback_mesh (x) (l:List ℕ) : windback x (mesh l)=mesh l.reverse := by
   have h:=backscan l [] (caplen (mesh l)) (by simp [caplen])
   exact exact_sweep (by simpa only [List.append_nil,mesh] using h) rfl

end ExactDerandomization.Relay

end

section

/-!
A recursive fixed program interface (only for algorithms whose
space certificates include the suspended calls). The replayed child
query is computed from the caller's tuple and suspended record. In
particular that recipe has **no** access to the caller's shared cursor.
Computed through already uniform functions (LF), charging those as
ephemeral scratch of log magnitude. -/
namespace ExactDerandomization.Relay
open Counter

structure Cub (α β : Type) [Wire α] [Wire β] where
    f : PT α β
    runs : Kn f

abbrev Site := ℕ×ℕ
abbrev Plot := ℕ×Site
abbrev Slip := ℕ×ℕ
abbrev Drain := Slip × Site
abbrev Flag := Cub Plot Bool

inductive Cog where
   | edit (move : Cub Plot Site)
   | toss (stem : Cub Slip ℕ) (send : Cub Drain Site)
   | seq (p q : Cog)
   | bif (cond : Flag) (p q : Cog)
   | loop (cond : Flag) (p : Cog)

structure Fare where
   limit : ℕ
   meter : ℕ→ℕ
def Fare.atm (v:Fare) (q : ℕ) (p : Site) :=
    q ≤ v.limit ∧ p.2 ≤ v.limit ∧ lb p.1≤v.meter q

def Fare.pull (v:Fare) (q h q':ℕ) := lb h+1+v.meter q'≤v.meter q

inductive Boots (x:Word) (F:Fare) (main : Cog) :
     ℕ → Cog → Site → Site → Prop
   | edit {q p a b} : p.f x (q,a)=b → F.atm q a → F.atm q b →
       Boots x F main q (.edit p) a b
   | toss {q p e a a' b q'} :
       p.f x (q,a.1)=q' → e.f x ((q,a.1),a')=b →
       F.atm q a → F.atm q b → F.pull q a.1 q' →
       Boots x F main q' main (0,a.2) a' →
       Boots x F main q (.toss p e) a b
   | seq {q p s a b c} : Boots x F main q p a b → Boots x F main q s b c →
       Boots x F main q (.seq p s) a c
   | yes {q u p s a b} : u.f x (q,a)=true → Boots x F main q p a b →
       Boots x F main q (.bif u p s) a b
   | no {q u p s a b} : u.f x (q,a)=false → Boots x F main q s a b →
       Boots x F main q (.bif u p s) a b
   | more {q u p a b c} : u.f x (q,a)=true → Boots x F main q p a b →
       Boots x F main q (.loop u p) b c →
       Boots x F main q (.loop u p) a c
   | lend {q u p a} : u.f x (q,a)=false → F.atm q a →
       Boots x F main q (.loop u p) a a

lemma Boots.fits {x F main q p a b} (h:Boots x F main q p a b) :
    F.atm q a ∧ F.atm q b:= by induction h <;> grind

inductive Act where
   | edit (move : Cub Plot Site) (goal : ℕ)
   | fork (u : Flag) (A B : ℕ)
   | toss (p : Cub Slip ℕ) (e : Cub Drain Site) (goal : ℕ)
   | rest

structure Grid where
    slot : ℕ
    entry : ℕ
    prog : ℕ → Act
    low : entry ≤ slot
    shut : prog 0=.rest
    dome : ∀ i,slot < i → prog i=.rest

namespace Grid
variable (r:Grid)

/-- routes represent synchronous, hence restoring-program-frame execution.
(They need not be cursor-restoring.) -/
inductive Route (r:Grid) (x:Word) (F:Fare) : ℕ→ℕ→Site→ℕ→Site→Prop
   | edit {q i a j b f} : r.prog i=.edit f j → f.f x (q,a)=b →
          i≤r.slot → j≤r.slot → F.atm q a → F.atm q b → Route r x F q i a j b
   | toss {q i a j b q' a' p e} : r.prog i=.toss p e j →
          p.f x (q,a.1)=q' → e.f x ((q,a.1),a')=b →
          i≤r.slot → j≤r.slot → F.atm q a → F.atm q b → F.pull q a.1 q' →
          Route r x F q' r.entry (0,a.2) 0 a' →
          Route r x F q i a j b
   | fork {q i a j f s t} : r.prog i=.fork f s t → (if f.f x (q,a) then s else t)=j →
          i≤r.slot → j≤r.slot → F.atm q a → Route r x F q i a j a
   | seq {q i a j b l c} : Route r x F q i a j b → Route r x F q j b l c → Route r x F q i a l c
lemma Route.fits {r x F q i a j b} (h:Route r x F q i a j b) :
    i≤r.slot ∧ j≤r.slot ∧ F.atm q a ∧ F.atm q b:= by induction h <;> grind

end Grid

namespace Cog

def Body : Cog→Type
   | .edit _| .toss ..=> Unit
   | .seq p q=> Body p ⊕ Body q
   | .loop _ p=> Unit ⊕ Body p
   | .bif _ p q=> Unit ⊕ (Body p ⊕ Body q)
instance (p:Cog) : Finite (Body p):=by
   induction p <;>(dsimp only [Body];infer_instance)

def first : (p : Cog) → Body p
   | .edit _| .toss ..=>()
   | .seq p _=> .inl (first p)
   | .loop ..| .bif ..=>.inl ()

def code : (p : Cog) → (Body p → ℕ) → ℕ → Body p → Act
   | .edit p,_,t,_=> .edit p t
   | .toss p q,_,t,_=> .toss p q t
   | .seq p q,f,_,.inl u=>code p (fun i=>f (.inl i)) (f (.inr (first q))) u
   | .seq _ q,f,t,.inr u=>code q (fun i=>f (.inr i)) t u
   | .loop c p,f,t,.inl _=>.fork c (f (.inr (first p))) t
   | .loop _ p,f,_,.inr u=>code p (fun i=>f (.inr i)) (f (.inl ())) u
   | .bif c p q,f,_,.inl _=> .fork c (f (.inr (.inl (first p)))) (f (.inr (.inr (first q))))
   | .bif _ p _,f,t,.inr (.inl u)=>code p (fun i=> f (.inr (.inl i))) t u
   | .bif _ _ q,f,t,.inr (.inr u)=>code q (fun i=> f (.inr (.inr i))) t u

lemma lays {r:Grid} {x F main} (m : Body main→ℕ)
   (hl:∀ i,m i≤r.slot) (he : ∀ i,r.prog (m i)=code main m 0 i)
   (hs : m (first main)=r.entry)
   {q p a b} (h:Boots x F main q p a b) (v:Body p → ℕ) (t:ℕ)
   (hu:∀ i,v i≤r.slot) (ht:t≤r.slot) (hh:∀ i,r.prog (v i)=code p v t i) :
    r.Route x F q (v (first p)) a t b := by
   induction h generalizing t with
   | edit e ha hb=> exact .edit (hh _) e (hu _) ht ha hb
   | toss u y ha hb h j ih=>
     exact .toss (hh _) u y (hu _) ht ha hb h (by rw [← hs]; exact ih m _ hl (Nat.zero_le _) he)
   | @seq q p z a b c h1 h2 ih1 ih2=>
     exact .seq (ih1 (fun i=> v (Sum.inl i)) _ (fun i=>hu _) (hu (Sum.inr (first z)))
                        (fun i=>hh (Sum.inl i)))
                (ih2 (fun i=>v (Sum.inr i)) t (fun i=>hu _) ht (fun i=>hh (Sum.inr i)))
   | @yes q f p z a b e h ih=>
     have hh1:= ih (fun i=>v (Sum.inr (Sum.inl i))) t (fun i=>hu _) ht (fun i=>hh (.inr (.inl i)))
     exact .seq (.fork (hh _) (ite_eq_left e) (hu _) (hu _) h.fits.1) hh1
   | @no q f p z a b e h ih=>
     have hh1:= ih (fun i=>v (Sum.inr (Sum.inr i))) t (fun i=>hu _) ht (fun i=>hh (.inr (.inr i)))
     exact .seq (.fork (hh _) (ite_eq_right (by simp [e])) (hu _) (hu _) h.fits.1) hh1
   | @more q f p a b c e h g ih1 ih2=>
     have hh2:= ih1 (fun i=>v (Sum.inr i)) (v (Sum.inl ())) (fun i=>hu _) (hu _)
           (fun i=> hh (.inr i))
     exact .seq (.fork (hh _) (ite_eq_left e) (hu _) (hu _) h.fits.1) (.seq hh2 (ih2 v t hu ht hh))
   | lend e h=> exact .fork (hh _) (ite_eq_right (by simp [e])) (hu _) ht h

lemma room (p:Cog) :
    ∃ r:Grid, ∀ {x F q a b}, Boots x F p q p a b → r.Route x F q r.entry a 0 b := by
   classical
   let:=Fintype.ofFinite (Body p)
   let e:=Fintype.equivFin (Body p)
   let n:=Fintype.card (Body p)
   let m : Body p→ℕ :=fun i=> (e i).val+1
   let f : ℕ→ Act := fun i=> if h : i<n+1∧i≠0 then code p m 0 (e.symm ⟨i-1,by omega⟩)
                                                 else .rest
   have hl (i) : m i≤ n := (e i).isLt
   let r:Grid:=⟨n,m (first p),f,hl _,by simp [f],fun i hi=> by
                                      exact dite_eq_right (by omega)⟩
   have he(i) : f (m i)=code p m 0 i := by
       unfold f
       have hz : m i<n+1∧m i≠0 := ⟨by have:=hl i; omega,Nat.succ_ne_zero _⟩
       rw [dite_eq_left hz]
       congr 1; simp [m,e]
   exact ⟨r,fun {_ _ _ _ _} h=> lays (r:=r) m hl he rfl h m 0 hl (Nat.zero_le n) he⟩

end Cog
end ExactDerandomization.Relay

end

section

namespace ExactDerandomization.Relay
open Counter
namespace Grid
variable (r:Grid)

abbrev Motor := ℕ × ℕ × Site
abbrev Hood := ℕ×ℕ
abbrev Carrier := Hood × Motor

/-- which query was invoked from this instruction -/
def fame (x:Word) (a q:ℕ) : ℕ :=
   let p : ℕ×ℕ:= dec a
   match r.prog p.1 with
   | .toss h _ _=>h.f x (q,p.2)
   | _=>0

def replay : PT (Hood × ℕ) ℕ :=
    sweep (fun x j => r.fame x j.2.1 j.2.2)
      (fun x j=>windback x j.2)
      (fun _ j=>j.1.2) (fun _ j=>j.1.1)

/-- finite branch selection -/
lemma numerous {α β : Type} [Wire α] [Wire β] (f: Act→ PT α β)
   (h:∀ p,Kn (f p)) (n:PT α ℕ) (hn:Kn n) :
    Kn (fun x a=> f (r.prog (n x a)) x a) := by
  classical
  have he(k) :
     Kn (fun x a=> if n x a<k then f (r.prog (n x a)) x a else f .rest x a) := by
     induction k with
     | zero=> simpa using h .rest
     | succ k ih=>
       convert hn.cond_eq (Kn.fix k) (h (r.prog k)) ih using 1
       ext x a
       by_cases hn:n x a=k <;> simp [hn] ; grind
  convert he (r.slot+1) using 1
  ext x a
  split
  · rfl
  · rw [r.dome _ (by omega)]

lemma fameK {α} [Wire α] (h k: PT α ℕ) (hs:Kn h) (he:Kn k) :
     Kn (fun x a=> r.fame x (h x a) (k x a)) := by
   let p : PT α (ℕ×ℕ):= fun x a=>dec (h x a)
   have hp : Kn p := Kn.unpack.comp hs
   let f (v:Act) : PT α ℕ:=fun x a=> match v with
     | .toss q _ _=> q.f x (k x a,(p x a).2)
     | _=>0
   apply r.numerous f ?_ _ hp.left
   intro j; cases j <;> first| exact Kn.fix _ | next p1 _ _=> exact p1.runs.comp (he.tuple hp.right)
lemma replayK : Kn r.replay := Kn.sweepK _ _ _ _
      (r.fameK _ _ Kn.next.left Kn.next.right)
      (Kn.windbackK.comp Kn.next) Kn.first.right Kn.first.left

def advance (r:Grid) (op:Act) (x:Word) (a:Carrier) : Motor :=
   let q:=r.replay x (a.1,a.2.2.1)
   let m:=a.2
   match op with
   | .edit f i=> (i,m.2.1, f.f x (q,m.2.2))
   | .fork f i j=> (if f.f x (q,m.2.2) then i else j,m.2.1,m.2.2)
   | .toss ..=> (r.entry,cord (enc (m.1,m.2.2.1)) m.2.1,0,m.2.2.2)
   | .rest=>m

def recede (r:Grid) (op:Act) (x:Word) (a:Carrier) : Motor :=
   let m:=a.2; let s:=aft m.2.1; let q:=r.replay x (a.1,s)
   match op with
   | .toss _ e i=> (i,s, e.f x ((q,(dec (fore m.2.1):ℕ×ℕ).2),m.2.2))
   | _=>m

def roll (r:Grid) (x:Word) (a:Carrier) : Motor :=
   let m:=a.2
   if m.1=0 then
     if m.2.1≤1 then m else r.recede (r.prog (dec (fore m.2.1):ℕ×ℕ).1) x a
   else r.advance (r.prog m.1) x a

lemma rollK : Kn r.roll := by
   have h0 : Kn (fun (_:Word) (a: Carrier)=> a.1) := Kn.first
   have h1 : Kn (fun (_:Word) (a: Carrier)=> a.2) := Kn.next
   have h2 : Kn (fun (_:Word) (a: Carrier)=> a.2.2.1) := h1.right.left
   have he : Kn (fun (_:Word) (a: Carrier)=> (dec (fore a.2.2.1):ℕ×ℕ)) :=
            Kn.unpack.comp h2.top
   apply h1.left.cond_eq (Kn.fix _)
      (h2.cond_le (Kn.fix _) h1 (r.numerous r.recede _ _ he.left))
      (r.numerous r.advance _ _ h1.left)
   · intro p
     cases p
     · exact h1
     · exact h1
     · next _ p i => exact (Kn.fix i).tuple (h2.tail.tuple
                      (p.runs.comp (((r.replayK.comp (h0.tuple h2.tail)).tuple he.right).tuple
                                    h1.right.right)))
     · exact h1
   intro p
   have hx := (r.replayK.comp (h0.tuple h2)).tuple h1.right.right
   cases p
   · next p i=> exact (Kn.fix i).tuple (h2.tuple (p.runs.comp hx))
   · next p i j => exact ((p.runs.comp hx).cond (Kn.fix i) (Kn.fix j)).tuple
                             (h2.tuple h1.right.right)
   · exact (Kn.fix r.entry).tuple
        (((Kn.wash.comp (h1.left.tuple h1.right.right.left)).push h2).tuple
            ((Kn.fix 0).tuple h1.right.right.right))
   · exact h1

lemma Scan.snatch {lim f x l q p a} (h:Scan lim f x l q) (hz: f a q=p) (hh:p≤lim) :
    Scan lim f x (l++[a]) p := by
   induction h
   · rw [← hz]; exact .cons (by assumption) (.nil (by omega))
   · apply Scan.cons (by assumption); apply_rules

lemma replay_s {x U q0 s q} (h:Scan U (r.fame x) q0 s.reverse q) :
   r.replay x ((U,q0),mesh s)=q :=
   exact_sweep (l:=s.reverse) h (windback_mesh ..)

lemma parked (x h a) : r.roll x (h,(0,1,a))=(0,1,a):=by simp [roll]

end Grid
end ExactDerandomization.Relay

end

section

namespace ExactDerandomization.Relay

/-- bounded transitive closure -/
inductive WPath {α} (safe:α→Prop) (g:α→α) : α→α→Prop
   | start {x} (h:safe x) : WPath safe g x x
   | next {x y z} : safe x → g x=y → WPath safe g y z → WPath safe g x z
lemma WPath.seq {α} {p:α→Prop} {g x y z} (h : WPath p g x y) (e:WPath p g y z): WPath p g x z := by
   induction h with | start=> exact e | next h g e ih=> exact .next h g (ih (by assumption))

namespace Grid
variable (r:Grid)

def elbow := 10*(lb r.slot+1)
lemma elbow_hi : 1 ≤ r.elbow := by unfold elbow; omega
def rooms (U : ℕ) := caplen U ^ (10*r.elbow)
abbrev fitsM (U:ℕ) (m:Motor) := enc m ≤ r.rooms U

lemma seats {F : Fare} {U q0 q s i a} (h:lb (mesh s)+r.elbow*F.meter q≤1+r.elbow*F.meter q0)
    (ht:i≤r.slot) (hf:F.atm q a)
    (hp:2^(F.meter q0) ≤ U) (hs:F.limit ≤ U) :
    r.fitsM U (i,mesh s,a) := by
   have hu:=lb_mono hp; rw [lb_shift] at hu
   have he:= r.elbow_hi
   have hm: F.meter q≤F.meter q0 := by
       have hz:=mesh_pos s
       have hb:=lb_pos (mesh s)
       nlinarith
   have hey:=lb_mono ht
   obtain ⟨ha,hb,hc⟩:=hf
   have hec:=lb_mono (hb.trans hs)
   have hx:=measure_pair i (mesh s,a)
   have hz:=measure_pair (mesh s) a
   have hh:=measure_pair a.1 a.2
   have hh0:=lb_pos U; have hg:=lb_pos r.slot
   change measure a≤2*lb a.1+lb a.2+2 at hh
   change measure (i,mesh s,a) ≤ 2*lb i+measure (mesh s,a)+2 at hx
   change measure (mesh s,a) ≤ 2*lb (mesh s)+measure a+2 at hz
   have hk : measure (i,mesh s,a) ≤ lb U*(10*r.elbow) :=by
       unfold elbow at *
       nlinarith [Nat.mul_le_mul_right (lb U) (show 1 ≤ lb r.slot from hg),
           Nat.mul_le_mul_left (10*(lb r.slot+1)) hu]
   exact le_trans (below _).le ((Nat.pow_le_pow_right Nat.zero_lt_two hk).trans_eq (by
      unfold rooms caplen; rw [pow_mul]))

lemma extends_by {F : Fare} {q0 q s i a q'} (h:lb (mesh s)+r.elbow*F.meter q≤1+r.elbow*F.meter q0)
    (ht:i≤r.slot) (hf:F.pull q a q') :
    lb (mesh (enc (i,a)::s))+r.elbow*F.meter q'≤1+r.elbow*F.meter q0 := by
   have h2 : lb (enc (i,a)) ≤ 2*lb i+lb a+2:=measure_pair i a
   have h3:=lb_mono ht
   rw [measure_mesh]
   unfold Fare.pull at hf
   have hp:=Nat.mul_le_mul_left r.elbow hf
   have he:=lb_pos a; have ht1:=lb_pos r.slot
   unfold elbow at *
   nlinarith

theorem journey {F : Fare} {x q0 U}
    (hp:2^(F.meter q0) ≤ U) (hs:F.limit ≤ U)
    {q i a j b} (h:r.Route x F q i a j b) {s}
    (hh:Scan U (r.fame x) q0 s.reverse q)
    (hz:lb (mesh s)+r.elbow*F.meter q≤1+r.elbow*F.meter q0) :
    WPath (r.fitsM U) (fun a=> r.roll x ((U,q0),a))
      (i,mesh s,a) (j,mesh s,b) := by
   induction h generalizing s with
   | @edit q i a j b f e l hi hj ha hb=>
     refine .next (r.seats hz hi ha hp hs) ?_ (.start (r.seats hz hj hb hp hs))
     have hk : i≠0 := fun hv=>by subst i; rw [r.shut] at e; contradiction
     simp [roll,advance,hk,e,r.replay_s hh,l]
   | @fork q i a j f s' t e l hi hj ha=>
     refine .next (r.seats hz hi ha hp hs) ?_ (.start (r.seats hz hj ha hp hs))
     have hk : i≠0 := fun hv=>by subst i; rw [r.shut] at e; contradiction
     simp [roll,advance,hk,e,r.replay_s hh,l]
   | @toss q i a j b q' a' p e he hl hu hi hj ha hb hf hm ih=>
     let w:= enc (i,a.1)
     have h1 : lb (mesh (w::s))+r.elbow*F.meter q'≤1+r.elbow*F.meter q0 :=r.extends_by hz hi hf
     have h2 : Scan U (r.fame x) q0 (w::s).reverse q':=by
          rw [List.reverse_cons]
          exact Scan.snatch hh (by simp [w,fame,he,hl]) (hm.fits.2.2.1.1.trans hs)
     have h3:= ih h2 h1
     refine .next (r.seats hz hi ha hp hs) ?_
         (h3.seq (.next (r.seats h1 (Nat.zero_le _) hm.fits.2.2.2 hp hs)
                          ?_ (.start (r.seats hz hj hb hp hs))))
     · have hk : i≠0 := fun hv=>by subst i; rw [r.shut] at he; contradiction
       simp [roll,advance,mesh,hk,he,w]
     have he1 : ¬(cord w (mesh s) ≤ 1):= not_le_of_gt (cord_fine ..).2.2
     simp only [roll,ite_true,recede,mesh,he1,ite_false,fore_cord,aft_cord,w,dec_round,he,r.replay_s hh,hu]
   | seq _ _ ih ig => exact (ih hh hz).seq (ig hh hz)

end Grid
end ExactDerandomization.Relay

end

section

namespace ExactDerandomization.Relay
open Counter

abbrev hitloop (f : ℕ→ℕ) (x:ℕ) := forNat (fun _=>f) x

lemma conserve {f:ℕ→ℕ} {L z} (h:z≤L) : ∀ n, hitloop (fun i=>min L (f i)) z n≤L := by
   intro n; cases n
   · exact h
   · exact min_le_left ..
lemma forever {f:ℕ→ℕ} {y z : ℕ} (h:f z=z) {j n} (hz:hitloop f y j=z) (hh:j≤ n) :
    hitloop f y n=z := by induction n,hh using Nat.le_induction <;> simp_all [hitloop,forNat]

lemma quick {f:ℕ→ℕ} {L x y}
   (hh:x≤L) (h:∀ n,f n≤L) (he:f y=y) (hr:∃ j,hitloop f x j=y) :
   hitloop f x L=y := by
   let j:=Nat.find hr
   have hz: hitloop f x j=y:= Nat.find_spec hr
   apply forever he hz
   have hv : Function.Injective (fun i : Fin (j+1)=>hitloop f x i.val) := by
      have hz1 {u v : Fin (j+1)} (ht:u<v) : hitloop f x u.val≠hitloop f x v.val := by
        intro hs
        have he1 (n:ℕ) : hitloop f x (u.val+n)=hitloop f x (v.val+n) := by
           induction n with
           | zero=> simpa using hs
           | succ n ih=>
             unfold hitloop at *; rw [show u.val+(n+1)=u.val+n+1 by omega,
                  show v.val+(n+1)=v.val+n+1 by omega,forNat,forNat,ih]
        have hx:= he1 (j-v.val)
        rw [show v.val+(j-v.val)=j by have:=v.isLt; omega,hz] at hx
        have hg:j≤u.val+(j-v.val):= Nat.find_min' hr hx
        have ht1:=v.isLt; exact (by change u.val < v.val at ht; omega)
      intro i v h; rcases lt_trichotomy i v with ht|ht|ht
      · exact (hz1 ht h).elim
      · exact ht
      · exact (hz1 ht h.symm).elim
   have hu (n) : hitloop f x n≤L:= by cases n; exact hh; exact h _
   let w : Fin (j+1)→ Fin (L+1) := fun i=>⟨_,Nat.lt_succ_of_le (hu i.val)⟩
   have he := Fintype.card_le_of_injective w fun i v hz=> hv (congrArg Fin.val hz)
   simpa using he

variable {α} [Wire α]

lemma WPath.clipIter {a b:α} {f L} (h:WPath (fun i:α=> enc i≤L) f a b) :
   enc a≤L ∧ enc b≤L ∧ ∃ j,hitloop (fun i=> min L (enc (f (dec i)))) (enc a) j=enc b := by
   induction h with
   | start ha=> exact ⟨ha,ha,0,rfl⟩
   | @next a v b ha he h ih=>
     obtain ⟨hv,hb,j,hz⟩:=ih
     refine ⟨ha,hb,j+1,?_⟩
     unfold hitloop; rw [forNat_cons,Wire.eq,he,min_eq_right hv]; exact hz

namespace Grid
variable (r:Grid)
abbrev Job := Hood × Site
def run (r : Grid) : PT Job Site :=
   fun x a=>
   let L:=r.rooms a.1.1
   let z:Motor:= (r.entry,1,a.2)
   let n:= hitloop (fun i : ℕ=> min L (enc (r.roll x (a.1,(dec i))))) (min L (enc z)) L
   (dec n : Motor).2.2

lemma runK : Kn r.run := by
   let L : PT Job ℕ:=fun _ a=>r.rooms a.1.1
   have e : Kn L:= Kn.power (10*r.elbow) (Kn.caplenK.comp Kn.first.left)
   let z : PT Job Motor :=fun _ a=>(r.entry,1,a.2)
   have he: Kn z:= (Kn.fix _).tuple ((Kn.fix _).tuple Kn.next)
   let f : PT (Job×ℕ×ℕ) ℕ:= fun x a=> min (L x a.1) (enc (r.roll x (a.1.1,dec a.2.2)))
   have ht : Kn f:= (e.comp Kn.first).small
            (Kn.wash.comp (r.rollK.comp (Kn.first.left.tuple (Kn.unpack.comp Kn.next.right))))
   have hh:= Kn.stroll f L _ L ht e (e.small (Kn.wash.comp he)) e (by
      intro x a j _
      cases j <;> exact min_le_left _ _)
   exact ((Kn.unpack (α:=Motor)).comp hh).right.right

lemma actual {x q F a b U} (ht:r.Route x F q r.entry a 0 b)
   (hu : 2^(F.meter q) ≤ U) (hv:F.limit≤U) : r.run x ((U,q),a)=b := by
   have hh : Scan U (r.fame x) q ([]:List ℕ) q := .nil (ht.fits.2.2.1.1.trans hv)
   have h:= r.journey hu hv ht (s:=[]) hh (by change lb 1+_≤_; rw [lb_one])
   obtain ⟨e,f,g⟩:=h.clipIter
   change enc (0,(1:ℕ),b)≤_ at f
   have he0 : min (r.rooms U) (enc (r.roll x ((U,q),
        dec (enc (0,(1:ℕ),b))))) = enc (0,(1:ℕ),b) := by
      rw [dec_round,r.parked,min_eq_right f]
   have he := quick e (fun i=> min_le_left (r.rooms U) (enc (r.roll x ((U,q),dec i))))
            he0 g
   unfold run
   dsimp only
   rw [min_eq_right (show enc (r.entry,(1:ℕ),a) ≤ r.rooms U from e)]
   change ((dec (hitloop _ (enc (r.entry,mesh [],a)) (r.rooms U)):Motor).2.2)=b
   rw [he,dec_round]

end Grid

/-- Compilation of simultaneous stack certificates. Partial logspace
function extension on all certified executions. -/
theorem realization (main:Cog) : ∃ f : PT Grid.Job Site, Kn f ∧ ∀ {x U F q a b},
   2^(F.meter q) ≤ U → F.limit ≤ U → Boots x F main q main a b →
    f x ((U,q),a)=b := by
   obtain ⟨r,h⟩:=main.room
   exact ⟨r.run,r.runK,fun ht he hz=> r.actual (h hz) ht he⟩

lemma Boots.same {F : Fare} {G : Fare} {p x q a b c}
    (h:Boots x F p q p a b) (e:Boots x G p q p a c) : b=c := by
   obtain ⟨f,_,hf⟩:=realization p
   let u:=max (max (2^(F.meter q)) F.limit) (max (2^(G.meter q)) G.limit)
   have hp : f x ((u,q),a)=b:=hf (le_trans (le_max_left _ _) (le_max_left _ _)) (le_trans (le_max_right _ _) (le_max_left _ _)) h
   have ht : f x ((u,q),a)=c:=hf (le_trans (le_max_left _ _) (le_max_right _ _)) (le_trans (le_max_right _ _) (le_max_right _ _)) e
   exact hp.symm.trans ht
end ExactDerandomization.Relay

end

section

/-! A local recipe layer, with spans accounting for numerical clock difference.
The allowance gap pays for both immediate structural information and any
overshoot in requested precision. -/
namespace ExactDerandomization.Relay
open Counter

abbrev span (c d t j x : ℕ) := x+c*j ≤ c*t+c*c*d
abbrev charge (c w t : ℕ):=c*t+c*c*w
lemma movespan {c d t j h e : ℕ} (u:span c d t j h) (hh:d ≤ e) :
    span c e t j h:= u.trans (Nat.add_le_add_left (Nat.mul_le_mul_left _ hh) _)

lemma leaner {c d t j x y : ℕ} (h:span c d t j y) (he:x≤y):span c d t j x :=
   le_trans (Nat.add_le_add_right he _) h

lemma acock {c d t j x} (h : span c d t j x) (he: 1≤ c) : j ≤ t+c*d:= by
   unfold span at h
   by_contra! hz; nlinarith

lemma lax {c d t j x} (h:span c d t j x) {D m : ℕ} (he:m*c ≤ D) (hp:1≤c) :
    m*x + D*j ≤ D*t+D*c*d := by
   obtain ⟨u,hD⟩:=Nat.exists_eq_add_of_le he
   have hz:=acock h hp
   unfold span at *
   have hu:=Nat.mul_le_mul_left u hz
   have hw:=Nat.mul_le_mul_left m h
   rw [hD]
   nlinarith

lemma span_mono {c d t j x} (h:span c d t j x) {D} (he:c ≤ D) (hp:1≤c):
    span D d t j x := by
   apply le_trans _ (Nat.add_le_add_left (Nat.mul_le_mul_right d (Nat.mul_le_mul_left D he)) (D*t))
   simpa only [one_mul] using lax h (m:=1) (by omega) hp

structure Level where
    w : ℕ
    t : ℕ

/-- fixed syntactic play, prices ignored until the enclosing layer is ready. -/
structure Lot where
    x : Word
    P : Cog
    F : Fare
    book : ℕ→Level

namespace Lot
variable (l:Lot)
def state (c : ℕ) (b : Level) (h:Site) :=
    h.2 ≤ l.F.limit ∧ span c b.w b.t 0 (lb h.1+1)
def jump (c : ℕ) (b : Level) (d h q:ℕ) :=
    let b':=l.book q
    b'.w+d ≤ b.w ∧ span c (b.w-b'.w) b.t b'.t (lb h+1)

/-- The clock argument is in b. q is the immutable tuple seen by the
inline recipe (may be virtual, i.e. regenerated via an inline frame). -/
inductive Mane (l:Lot) (c : ℕ) (b : Level) (d : ℕ) (q : ℕ) : Cog→Site→Site→Prop
   | edit {p h j} : p.f l.x (q,h)=j → l.state c b h → l.state c b j →
         Mane l c b d q (.edit p) h j
   | toss {p e a a' u q'} :
       p.f l.x (q,a.1)=q' → e.f l.x ((q,a.1),a')=u →
       l.state c b a → l.state c b u → l.jump c b d a.1 q' →
       Boots l.x l.F l.P q' l.P (0,a.2) a' →
       Mane l c b d q (.toss p e) a u
   | seq {p s a y u} : Mane l c b d q p a y → Mane l c b d q s y u →
       Mane l c b d q (.seq p s) a u
   | yes {s u p a y} : s.f l.x (q,a)=true → Mane l c b d q p a y →
       Mane l c b d q (.bif s p u) a y
   | no {s u p a y} : s.f l.x (q,a)=false → Mane l c b d q u a y →
       Mane l c b d q (.bif s p u) a y
   | more {s p a y v} : s.f l.x (q,a)=true → Mane l c b d q p a y →
       Mane l c b d q (.loop s p) y v → Mane l c b d q (.loop s p) a v
   | stop {s p a} : s.f l.x (q,a)=false → l.state c b a → Mane l c b d q (.loop s p) a a

lemma Mane.spots {l c b d q p a y} (h:Mane l c b d q p a y) : l.state c b a ∧ l.state c b y:=
   by induction h <;> grind

lemma Mane.mono {l c b d q p a y} (h:Mane l c b d q p a y) {D}
   (he:c ≤ D) (hp:1≤c) :
     Mane l D b d q p a y := by
   have hs {v:Site} (e:l.state c b v) : l.state D b v:=⟨e.1,span_mono e.2 he hp⟩
   have ht {v t} (e:l.jump c b d v t) : l.jump D b d v t:=⟨e.1,span_mono e.2 he hp⟩
   induction h
   · apply Mane.edit (by assumption) (hs ‹_›) (hs ‹_›)
   · rename_i q' e f _ _ _ g
     exact .toss e f (hs ‹_›) (hs ‹_›) (ht ‹_›) g
   · exact .seq (by assumption) (by assumption)
   · exact .yes (by assumption) (by assumption)
   · exact .no (by assumption) (by assumption)
   · exact .more (by assumption) (by assumption) (by assumption)
   · exact .stop (by assumption) (hs ‹_›)

theorem Mane.issue {l c b d q p a y} (h:Mane l c b d q p a y) (hb:b=l.book q) (hu:q≤l.F.limit)
   (ht : ∀ x, l.F.meter x=charge c (l.book x).w (l.book x).t) :
     Boots l.x l.F l.P q p a y:= by
   have hs {v:Site} (e:l.state c b v) : l.F.atm q v := by
     refine ⟨hu,e.1,?_⟩
     rw [ht q,← hb]
     obtain ⟨-,he⟩:= e; unfold span charge at *; omega
   have he {v t} (e:l.jump c b d v t) : l.F.pull q v t := by
      obtain ⟨hz,hu⟩:= e
      have hl: (b.w-(l.book t).w)+(l.book t).w=b.w:=by omega
      unfold Fare.pull; rw [ht t,ht q,← hb]; unfold span charge at *
      nlinarith [congrArg (fun w=> c*c*w) hl]
   induction h
   · exact .edit (by assumption) (hs ‹_›) (hs ‹_›)
   · rename_i q' e f _ _ _ g
     exact .toss e f (hs ‹_›) (hs ‹_›) (he ‹_›) g
   · exact .seq (by assumption) (by assumption)
   · exact .yes (by assumption) (by assumption)
   · exact .no (by assumption) (by assumption)
   · exact .more (by assumption) (by assumption) (by assumption)
   · exact .lend (by assumption) (hs ‹_›)

end Lot

def hold (o:ℕ) (a:Site) : Site := (enc (o,a.1),a.2)
def mark (a:ℕ) := (dec a:ℕ×ℕ).1
def unseat (a:ℕ) := (dec a:ℕ×ℕ).2

lemma marked (o h) : mark (enc (o,(h:ℕ)))=o := by simp [mark]
lemma unseats0 (o h) : unseat (enc ((o:ℕ),h))=(h:ℕ) :=by simp [unseat]
lemma holdcap {c C g o} {a : ℕ} {d t j k : ℕ}
   (h:span C d j k (lb a+1)) (e:span c d t j (lb o+1))
   (hh:2*c+C≤g) (hc:1≤ c) (hx:1≤ C) :
     span g d t k (lb (enc (o,a))+1) := by
   have h1:=lax h (m:=1) (show 1*C≤g by omega) hx
   have h2:=lax e (m:=2) (show 2*c≤g by omega) hc
   have he : lb (enc (o,a)) ≤2*lb o+lb a+2:=measure_pair o a
   have hl:= Nat.mul_le_mul_left (g*d) (show C+c≤g by omega)
   unfold span
   nlinarith

namespace Cog
variable (f:Cub Slip ℕ)
def locate (a:Cub Slip ℕ) : PT Plot Plot :=
   fun x p=> (a.f x (p.1,mark p.2.1),unseat p.2.1,p.2.2)
lemma location : Kn (locate f):= by
   let p (_:Word) (a:Plot):= (dec a.2.1:ℕ×ℕ)
   have ht:Kn p:= Kn.unpack.comp Kn.next.left
   exact (f.runs.comp (Kn.first.tuple ht.left)).tuple (ht.right.tuple Kn.next.right)

lemma binds {α} [Wire α] (o:PT α ℕ) (a:PT α Site) (h:Kn o) (e:Kn a) :
   Kn (fun x v=> hold (o x v) (a x v)):= (Kn.wash.comp (h.tuple e.left)).tuple e.right

theorem markK {α} [Wire α] {a:PT α ℕ} (e:Kn a) :
    Kn (fun x v=> mark (a x v)):= Kn.left ((Kn.unpack (α:=ℕ×ℕ)).comp e)
theorem unseatK {α} [Wire α] {a:PT α ℕ} (e:Kn a) :
    Kn (fun x v=> unseat (a x v)):= Kn.right ((Kn.unpack (α:=ℕ×ℕ)).comp e)

def guard0 (p:Flag) : Flag := ⟨fun x a=>p.f x (locate f x a),p.runs.comp (location f)⟩

/-- Inlining carries an inner tuple regenerated from q and the piece o. -/
def focus (v:Cog) : Cog :=
   match v with
   | .edit p=> .edit ⟨fun x a=> hold (mark a.2.1) (p.f x (locate f x a)),
                       binds _ _ (markK Kn.next.left) (p.runs.comp (location f))⟩
   | .toss p g=> .toss ⟨fun x a=> p.f x (f.f x (a.1,mark a.2),unseat a.2),
                       p.runs.comp ((f.runs.comp (Kn.first.tuple (markK Kn.next))).tuple (unseatK Kn.next))⟩
                       ⟨fun x a=>let o:=mark a.1.2
                                 hold o (g.f x ((f.f x (a.1.1,o),unseat a.1.2),a.2)),
                        binds _ _ (markK Kn.first.right) (g.runs.comp
                            (((f.runs.comp (Kn.first.left.tuple (markK Kn.first.right))).tuple
                              (unseatK Kn.first.right)).tuple Kn.next))⟩
   | .seq q w=>.seq (focus q) (focus w)
   | .bif p q w=>.bif (guard0 f p) (focus q) (focus w)
   | .loop p q=>.loop (guard0 f p) (focus q)

lemma hitmark {x q o r} (h:f.f x (q,o)=r) (a:Site) :
     locate f x (q,hold o a)=(r,a):=by simp [locate,hold,marked,unseats0,h]

lemma focus_word {l c w j d r p a y} (h:Lot.Mane l c ⟨w,j⟩ d r p a y)
    {C g o t q} (he:f.f l.x (q,o)=r)
    (hr:span C d t j (lb o+1))
    (hf:d≤w) (hz:2*C+c≤g) (hc:1≤ c) (hu:1≤ C) :
    Lot.Mane l g ⟨w,t⟩ d q (focus f p) (hold o a) (hold o y):= by
   have ha {a : Site} (h:l.state c ⟨w,j⟩ a) : l.state g ⟨w,t⟩ (hold o a):=
      ⟨h.1, holdcap h.2 (movespan hr hf) hz hu hc⟩
   have hs {a q} (h:l.jump c ⟨w,j⟩ d a q) : l.jump g ⟨w,t⟩ d (enc (o,a)) q := by
      refine ⟨h.1,holdcap h.2 (movespan hr ?_) hz hu hc⟩
      have hp :(l.book q).w+d ≤ w:=h.1; dsimp only; omega
   induction h
   · rename_i e ha1 ha2
     apply Lot.Mane.edit _ (ha ha1) (ha ha2)
     simp [locate,hold,e,marked,unseats0,he]
   · rename_i q' e y1 ha1 ha2 h3 h4
     refine Lot.Mane.toss ?_ ?_ (ha ha1) (ha ha2) (hs h3) h4
     all_goals simp only [hold,marked,unseats0,he,e,y1]
   · exact .seq (by assumption) (by assumption)
   · rename_i e h ih
     refine .yes ?_ ih; simp only [guard0,hitmark f he,e]
   · rename_i e h ih
     refine .no ?_ ih; simp only [guard0,hitmark f he,e]
   · rename_i e h h' ih ih'
     refine .more ?_ ih ih'; simp only [guard0,hitmark f he,e]
   · rename_i e h; refine .stop ?_ (ha h); simp only [guard0,hitmark f he,e]

end Cog
end ExactDerandomization.Relay

end

section

namespace ExactDerandomization.Relay

variable {α β : Type} [Wire α] [Wire β]
abbrev Lore (α) := ℕ×α
abbrev Pause (v : α) (c:ℕ) : Site := (enc v,c)

def topNote (f:PT (Lore α) β) (h:Kn f) : Cub Plot Site :=
   ⟨fun x a=> (enc (f x (a.1, dec a.2.1)),a.2.2),
     (Kn.wash.comp (h.comp (Kn.first.tuple (Kn.unpack.comp Kn.next.left)))).tuple Kn.next.right⟩
def etch (f:PT (Lore α) β) (h:Kn f) : Cog := .edit (topNote f h)
def gear (f:PT (Lore α) Bool) (h:Kn f) : Flag :=
   ⟨fun x a=> f x (a.1, dec a.2.1),h.comp (Kn.first.tuple (Kn.unpack.comp Kn.next.left))⟩

lemma gear_at (f:PT (Lore α) Bool) (h:Kn f) (x q a c) :
   (gear f h).f x (q,Pause a c)=f x (q,a) := by simp [gear,Pause]
lemma etches (f:PT (Lore α) β) (h:Kn f) {l : Lot} {c b d q i j w}
    (hz:f l.x (q,i)=j) (hv:l.state c b (Pause i w)) (hy:l.state c b (Pause j w)) :
    Lot.Mane l c b d q (etch f h) (Pause i w) (Pause j w):=
   .edit (by simp [topNote,Pause,hz]) hv hy

lemma Kn.bneg (f:PT α Bool) (h: Kn f) : Kn (fun x a=> !(f x a)) := by
   convert h.cond (Kn.fix false) (Kn.fix true) using 1
   ext x a
   cases he:f x a <;> simp []

end ExactDerandomization.Relay

end

end OAI