import OAI.Computability.Logspace.RecursivePrograms

namespace OAI

/-!
Contour traversal of finite functional graphs with explicit predecessor enumeration.

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

set_option autoImplicit true

section

/-!
Contour on a functional graph with raw-name-labelled cursor nodes.
Include slots for absent incidences. This enables scanning arbitrary raw
program records of comparable size for predecessors; incidence
alphabets at this graph layer need not be bounded by constants. -/
namespace ExactDerandomization.Swirl
open Relay Finset

abbrev Dot := ℕ×ℕ
abbrev Gem := Dot×ℕ

structure Fir where
   V : Finset Dot
   rad : ℕ → ℕ
   up : Dot → Option Dot
   kid : Dot → ℕ → Option Dot
   pairU : ∀ x∈V,∀ {y},up x=some y  →
       y∈V ∧ y.1 < rad x.1 ∧ x.1 < rad y.1 ∧ kid y x.1=some x
   pairK : ∀ y∈V,∀ i {x},kid y i=some x  →  x∈V ∧ up x=some y ∧ x.1=i

namespace Fir
variable (g:Fir)

def broad (x:Dot):=g.rad x.1
def finalx (x:Dot):Gem := (x,g.broad x)
def roll (x:Gem): Gem :=
   let p:=x.1; let i:=x.2
   if i < g.broad p then
      match g.kid p i with
      | none=>(p,i+1)
      | some y=>(y,0)
   else
      match g.up p with
      | none=>(p,0)
      | some y=>(y,p.1+1)
def fold (x:Gem): Gem :=
   let p:=x.1; let i:=x.2
   if i=0 then
       match g.up p with
       | none=> (p,g.broad p)
       | some y=> (y,p.1)
   else
       match g.kid p (i-1) with
       | none=>(p,i-1)
       | some y=>(y,g.broad y)

def live (x:Gem):= x.1∈g.V ∧ x.2 ≤ g.broad x.1

lemma forward {x} (h:g.live x) : g.live (g.roll x) ∧ g.fold (g.roll x)=x := by
   rcases x with ⟨p,i⟩; obtain ⟨hz,ht⟩:=h
   change i≤g.broad p at ht
   change p∈g.V at hz
   by_cases hi:i<g.broad p
   · cases he:g.kid p i with
     | none=> simp [live,roll,fold,hi,he,hz]
     | some y=>
       obtain ⟨ha,hb,hc⟩:=g.pairK p hz i he
       simp [live,roll,fold,hi,he,hb,hc,ha]
   cases he:g.up p with
   | none=> simp [live,roll,fold,hz,hi,he]; omega
   | some y=>
      obtain ⟨ha,hb,hc,hd⟩:=g.pairU p hz he
      change p.1<g.broad y at hc
      simp [live,roll,fold,hi,he,ha,hd]; omega

inductive Flight (S:Dot) : ℕ → Dot → Prop
  | node (h:S∈g.V): Flight S 0 S
  | above {n y x} (h:x∈g.V) (e:g.up x=some y) (p:Flight S n y):
                  Flight S (n+1) x

lemma Flight.on {g:Fir} {S n x} (h:g.Flight S n x):x∈g.V:=by cases h <;> assumption
lemma Flight.unique {g:Fir} {S n m x} (h:g.Flight S n x) (e:g.Flight S m x) (ha:g.up S=none) : m=n := by
   induction h generalizing m with
   | node hx =>
     cases e <;> simp_all
   | above hx hh hk ih=> cases e <;> simp_all

lemma quota {S} (hs:g.up S=none) : ∃ d, ∀ {x n},g.Flight S n x → n≤d := by
  classical
  have he (p : Finset Dot) : ∃ d, ∀ {x n},x∈p → g.Flight S n x → n≤d := by
     induction p using Finset.induction_on with
     | empty=> exact ⟨0, by simp⟩
     | @insert a p ha ih=>
       obtain ⟨d,h⟩:=ih
       by_cases hh:∃ n,g.Flight S n a
       · obtain ⟨n,hk⟩:=hh
         refine ⟨n+d,fun {x i} hu hm=>?_⟩
         obtain rfl|hz:=mem_insert.1 hu
         · rw [Flight.unique hk hm hs]; omega
         have he:= h hz hm; omega
       refine ⟨d,fun {x i} hu hm=>h ?_ hm⟩
       obtain rfl|hz:=mem_insert.1 hu
       · exact (hh ⟨i,hm⟩).elim
       exact hz
  obtain ⟨d,hk⟩:=he g.V; exact ⟨d,fun {_ _} h=>hk h.on h⟩

def nest (S:Dot) (p:Gem) := g.live p ∧ ∃ n,g.Flight S n p.1
lemma rise {S p} (hS:g.up S=none) (h:g.nest S p):g.nest S (g.roll p):= by
   have he:=g.forward h.1; refine ⟨he.1,?_⟩
   rcases p with ⟨v,i⟩
   obtain ⟨hz,n,h⟩:=h
   change g.Flight S n v at h
   by_cases hk:i<g.broad v
   · cases hu:g.kid v i with
     | none=> simp [roll,hk,hu]; exact ⟨n,h⟩
     | some x=>
       obtain ⟨ha,hb,-⟩:=g.pairK v hz.1 i hu
       simp [roll,hk,hu]; exact ⟨_,.above ha hb h⟩
   cases e:g.up v with
   | none=> simp [roll,hk,e]; exact ⟨n,h⟩
   | some w=>
      simp [roll,hk,e]
      cases h with
      | node=> simp_all
      | @above i v hx hv hw=> simp_all; aesop

end Fir

def lap {α} (f:α → α) (v:α) : ℕ → α
   | 0=> v
   | n+1=> f (lap f v n)

section
variable {α:Type} (f:α → α)
lemma laps (v i j): lap f v (i+j)=lap f (lap f v i) j := by
   induction j with | zero=> simp [lap] | succ j ih=> rw [← add_assoc,lap,ih,lap]

def Link (x y : α):= ∃ i, lap f x i=y
lemma Link.seq {f x y z} (h:Link (α:=α) f x y) (e:Link f y z):Link f x z:=by
   obtain ⟨i,rfl⟩:=h; obtain ⟨j,rfl⟩:=e; exact ⟨_,laps ..⟩
lemma same (x:α) : Link f x x:=⟨0,rfl⟩
lemma ride {x y} (h:f x=y): Link f x y:=⟨1,h⟩
end

namespace Fir
variable (g:Fir)

lemma between {S} (hs:g.up S=none) :
    ∀ {n x},g.Flight S n x  →  ∀ i, i≤g.broad x  →
                   Link g.roll (x,0) (x,i) := by
   obtain ⟨d,h⟩:=g.quota hs
   suffices ht:∀ j {n x}, d ≤ n+j → g.Flight S n x  →
       ∀ i,i≤g.broad x → Link g.roll (x,0) (x,i) by
     exact fun {_ _} e => ht d (by omega) e
   intro j
   induction j with
   | zero=>
      intro n x hh he i ha
      induction i with
      | zero=> exact same ..
      | succ i ih=>
        apply Link.seq (ih (by omega))
        have hi:i<g.broad x:=by omega
        cases hz:g.kid x i with
        | none=> apply ride; simp [roll,hz,hi]
        | some y=>
          obtain ⟨h1,h2,h3⟩:=g.pairK x he.on i hz
          have hk:=h (Flight.above h1 h2 he); omega
   | succ j ih=>
      intro n x hh he i ha
      induction i with
      | zero=> exact same ..
      | succ i hi=>
         apply Link.seq (hi (by omega))
         have hi:i<g.broad x:=by omega
         cases hz:g.kid x i with
         | none=> apply ride; simp [roll,hz,hi]
         | some y=>
           obtain ⟨h1,h2,h3⟩:=g.pairK x he.on i hz
           have hy:= ih (show d ≤ n+1+j by omega) (Flight.above h1 h2 he) (g.broad y) le_rfl
           exact .seq (ride _ (by simp [roll,hz,hi])) (.seq hy (ride _ (by simp [roll,h2,h3])))

lemma orbit {S p} (hs:g.up S=none) (h:g.nest S p) :
    Link g.roll (S,0) p := by
   rcases p with ⟨x,i⟩; obtain ⟨hx,n,h⟩:=h
   change g.Flight S n x at h
   apply Link.seq _ (g.between hs h _ hx.2)
   clear hx
   induction h with
   | node=> exact same ..
   | @above n y x hx he hy ih=>
     obtain ⟨ha,hb,hc,hd⟩:=g.pairU x hx he
     exact .seq ih (.seq (g.between hs hy _ hc.le) (ride _ (by
           simp [roll,hc,broad,hd])))
lemma whirl {S} (hs:S∈g.V) (hh:g.up S=none) :
    ∃ n, lap g.roll (S,0) (n+1)=(S,0) := by
   obtain ⟨i,hi⟩:=g.between hh (Flight.node hs) (g.broad S) le_rfl
   exact ⟨i,by rw [lap,hi]; simp [roll,hh]⟩

end Fir
end ExactDerandomization.Swirl

end

section

namespace ExactDerandomization.Swirl
open Relay

variable {α:Type}

/-- Linear link with internal points explicit; endpoints can coincide. -/
inductive Stripe (r:α→α→Prop) : α→List α→α→Prop
  | run {x y} (h:r x y) : Stripe r x [] y
  | hook {x y z l} : r x y → Stripe r y l z → Stripe r x (y::l) z

namespace Stripe
variable {r w : α→α→Prop}

lemma joins {x y z l m} (h:Stripe r x l y) (e:Stripe r y m z):Stripe r x (l++y::m) z:=by
   induction h with
   | run hp=>exact .hook hp e
   | hook hz _ ih=> exact .hook hz (ih (by assumption))

lemma both {x u l} (h:Stripe r x u l)
    (hr:∀ a b,r a b → w b a) : Stripe w l u.reverse x := by
   induction h with
   | run h=> exact .run (hr _ _ h)
   | hook h e ih=>
     rw [List.reverse_cons]
     exact joins ih (.run (hr _ _ h))

lemma every {x l y} (h:Stripe r x l y) (hz:∀ x y,r x y → w x y):
    Stripe w x l y := by induction h with
    | run h=> exact .run (hz _ _ h)
    | hook h _ ih=> exact .hook (hz _ _ h) ih

lemma sever {x y z a b} (h:Stripe r x (a++z::b) y):
    Stripe r x a z ∧ Stripe r z b y := by
   induction a generalizing x with
   | nil=> cases h with | hook u v=> exact ⟨.run u,v⟩
   | cons j a ih=>
     cases h with
     | hook u v=>
       obtain ⟨hv,hw⟩:=ih v; exact ⟨.hook u hv,hw⟩

end Stripe

inductive Flare (r:α→α→Prop) (f:α→Bool) : α→α→Prop
   | arrive {x y} : r x y → f y=true → Flare r f x y
   | climb {x y z} : r x y → f y=false → Flare r f y z → Flare r f x z

lemma stripes {r:α→α→Prop} {x y l} (h:Stripe r x l y) (v:α→Bool) (e:v y=true):
    Stripe (Flare r v) x (l.filter v) y:= by
   induction h with
   | run hz=> exact .run (.arrive hz e)
   | @hook x a y l h t ih=>
     specialize ih e
     by_cases ht:v a=true
     · simp [ht]; exact .hook (.arrive h ht) ih
     replace ht:v a=false:=by simp_all
     rw [List.filter_cons_of_neg]; swap; simp [ht]
     generalize he:l.filter v=m at *
     cases ih with
     | run ha=> exact .run (.climb h ht ha)
     | hook ha hb=> exact .hook (.climb h ht ha) hb

namespace Rope
variable (f:α→α)
def rope (x:α) : ℕ→ List α
   | 0=>[]
   | n+1=> f x :: rope (f x) n

lemma before (x i) : lap f x (i+1) = lap f (f x) i:= by
   rw [show i+1=1+i by omega,laps]; rfl

lemma paid (S : α→Prop) (h:∀ i,S i→ S (f i))
   (x:α) (e:S x) (n) :
   Stripe (fun i j=> S i ∧ f i=j) x (rope f x n) (lap f x (n+1)):= by
   induction n generalizing x with
   | zero=> exact .run ⟨e,rfl⟩
   | succ n ih=>
      rw [rope,before]
      exact .hook ⟨e,rfl⟩ (ih _ (h _ e))

lemma sat {x y:α} {n} : y∈rope f x n ↔ ∃ i<n,lap f x (i+1)=y:= by
   induction n generalizing x with
   | zero=> simp [rope]
   | succ n ih=>
     simp only [rope,List.mem_cons,ih]
     constructor
     · rintro (rfl|⟨i,hi,e⟩)
       · exact ⟨0,by omega,rfl⟩
       exact ⟨i+1,by omega,(before f x (i+1)).trans e⟩
     rintro ⟨i,h,e⟩; cases i with
     | zero=>left; exact e.symm
     | succ i=> exact Or.inr ⟨i,by omega,(before f x (i+1)).symm.trans e⟩

lemma repeatZ {x:α} {n} (h:lap f x (n+1)=x) (i:ℕ) :
    ∃ j, j≤n∧ lap f x j=lap f x i:= by
   induction i using Nat.strong_induction_on with | h i ih =>
    by_cases he:i≤n
    · exact ⟨i,he,rfl⟩
    have hu : n+1+(i-(n+1))=i := by omega
    obtain ⟨j,hj,hk⟩:= ih (i-(n+1)) (by omega)
    refine ⟨j,hj,hk.trans ?_⟩
    exact (calc
        lap f x i= _ := congrArg _ hu.symm
        _= lap f (lap f x (n+1)) (i-(n+1)):=laps ..
        _= _:=by rw [h]).symm

lemma clean {x:α} {n} (h: ∀ j, j≤n → ∀ i<j, lap f x i≠lap f x j) :
    (x::rope f x n).Nodup:=by
   induction n generalizing x with
   | zero=> simp [rope]
   | succ n ih=>
     refine List.nodup_cons.2 ⟨?_,?_⟩
     · intro hz; obtain ⟨i,hi,e⟩:= (sat _).1 hz
       exact h _ hi 0 (by omega) e.symm
     rw [rope]; apply ih
     intro j hj i hi
     rw [← before,← before]
     exact h (j+1) (by omega) (i+1) (by omega)

lemma cutpoint {S:α→Prop} {x} (hh:S x) (hz:∀ a,S a → S (f a))
   (hr : ∀ a,S a → Link f x a) (he:∃ n,lap f x (n+1)=x) :
   ∃ l, (x::l).Nodup ∧ (∀ a,a∈x::l ↔ S a) ∧ Stripe (fun i j=> S i ∧ f i=j) x l x:= by
  classical
  let n:=Nat.find he
  have hp:lap f x (n+1)=x:= Nat.find_spec he
  refine ⟨rope f x n,clean _ ?_,fun a=>?_,by
    have hh:=paid f S hz x hh n; rw [hp] at hh; exact hh⟩
  · intro j hj i hi h
    have e1 : lap f x (i+(n+1-j))=x := by
       rw [laps,h,← laps,show j+(n+1-j)=n+1 by omega,hp]
    have ht := Nat.find_min' he (show lap f x (i+(n-j)+1)=x by
                      rw [show i+(n-j)+1=i+(n+1-j) by omega,e1])
    change n≤_ at ht
    omega
  · rw [List.mem_cons,sat]
    have ht(i): S (lap f x i):=by induction i with | zero=>exact hh | succ i ih=> exact hz _ ih
    constructor
    · rintro (rfl|⟨i,hj,rfl⟩)
      · exact hh
      exact ht _
    intro hy
    obtain ⟨i,rfl⟩:=hr a hy
    obtain ⟨j,hj,he⟩:=repeatZ f hp i
    cases j with
    | zero=> left; exact he.symm
    | succ j=> exact Or.inr ⟨_,hj,he⟩

end Rope

namespace Fir
variable (g:Fir)
def march (b:Bool) (i j:Gem) := g.live i ∧ (if b then g.roll i else g.fold i)=j ∧ g.live j
lemma streak {S} (hs:S∈g.V) (hh:g.up S=none) (m:Gem→Bool) (hm:m (S,0)=true) :
    ∃ l: List Gem, ((S,0)::l).Nodup ∧
       (∀ a,a∈(S,0)::l ↔ g.nest S a ∧ m a=true) ∧
       Stripe (Flare (march g true) m) (S,0) l (S,0) ∧
       Stripe (Flare (march g false) m) (S,0) l.reverse (S,0):= by
   have hr : g.nest S (S,0):=⟨⟨hs,Nat.zero_le _⟩,⟨0, Flight.node hs⟩⟩
   let v : Gem := (S,0)
   let p i j:=g.nest S i ∧ g.roll i=j
   obtain ⟨l,hl,he,h⟩:= Rope.cutpoint g.roll hr (fun a e=>g.rise hh e)
                     (fun a e=>g.orbit hh e) (g.whirl hs hh)
   have h1 : ∀ a b,p a b → march g true a b := by
      rintro a b ⟨e,rfl⟩; exact ⟨e.1,rfl,(g.forward e.1).1⟩
   have h2 : ∀ a b,march g true a b → march g false b a := by
      rintro a b ⟨e,rfl,h⟩; exact ⟨h,(g.forward e).2,e⟩
   have hh : Stripe (march g false) v l.reverse v :=
         h.both (fun a b q=>h2 a b (h1 a b q))
   have hg : Stripe (march g true) v l v:= h.every h1
   refine ⟨l.filter m,?_,fun i=>?_,stripes hg m hm,?_⟩
   · simpa [hm] using hl.filter m
   · have hz:= he i
     simp only [List.mem_cons,List.mem_filter]
     grind
   simpa using stripes hh m hm

end Fir
end ExactDerandomization.Swirl

end

section

namespace ExactDerandomization.Swirl
open Relay

def Fir.riseQ (g:Fir) (v:Dot) (i:ℕ):Option Dot :=
   match g.up v with
   | some y=> if y.1=i then some y else none
   | none=>none
def Fir.probe (g:Fir) (parent:Bool) (v:Dot) (i:ℕ) :=
   if parent then g.riseQ v i else g.kid v i

abbrev Seat := ℕ×ℕ
abbrev Panel := Bool×Seat

structure Arena where
    l : Lot
    b : Level
    d : ℕ
    q : ℕ
    cost : ℕ
    trees : Fir
    hand : ℕ→ℕ

namespace Arena
variable (s:Arena)
abbrev acts := Lot.Mane s.l s.cost s.b s.d s.q
abbrev wait {α} [Wire α] (v:α) (c:ℕ):Site := Pause v (s.hand c)
abbrev tag (p:Gem) (f:Bool :=false) : Site := s.wait ((f,p.1.1,p.2):Panel) p.1.2

def touch (b:Bool) (v:Dot) (i:ℕ):Site :=
    match s.trees.probe b v i with
    | none=> s.tag (v,i) false
    | some w=> s.wait ((true,v.1,i):Panel) w.2

end Arena

structure Shows where
    rad : Cub (Lore ℕ) ℕ
    marked : Cub (Lore Seat) Bool
    probes : Bool→ Cog
namespace Shows
variable (p:Shows)

abbrev Chart := Lore Panel

def ray (x:Word) (a:Chart) := p.rad.f x (a.1,a.2.2.1)
lemma rayK : Kn p.ray:=p.rad.runs.comp (Kn.first.tuple Kn.next.right.left)

def keep (x:Word) (a:Chart) : Bool :=
   if a.2.1 then false else decide (a.2.2.2< p.ray x a)
lemma keepK : Kn p.keep:= Kn.next.left.cond (Kn.fix _) (Kn.next.right.right.lt p.rayK)

def upmov (dir:Bool) (_:Word) (a:Chart) : Panel :=
    let (b,v,i):=a.2
    if b then (true,i,if dir then v+1 else v)
    else (false,v,i+1)
lemma upK (b): Kn (upmov b):=by
    have ht : Kn (fun (_:Word) (a:Chart)=>a.2):=Kn.next
    let v:=upmov b
    change Kn v
    cases b
    · exact ht.left.cond ((Kn.fix _).tuple (ht.right.right.tuple ht.right.left))
                  ((Kn.fix _).tuple (ht.right.left.tuple ht.right.right.succ))
    · exact ht.left.cond ((Kn.fix _).tuple (ht.right.right.tuple ht.right.left.succ))
                  ((Kn.fix _).tuple (ht.right.left.tuple ht.right.right.succ))

def summit (p:Shows) (dir:Bool) (x:Word) (a:Chart) : Panel :=
    let (b,v,i):=a.2
    (false,v, if b then i else if dir then 0 else p.rad.f x (a.1,v))
lemma summitK (b):Kn (p.summit b):=by
    have ht : Kn (fun (_:Word) (a:Chart)=>a.2):=Kn.next
    cases b
    · exact (Kn.fix _).tuple (ht.right.left.tuple (ht.left.cond ht.right.right p.rayK))
    · exact (Kn.fix _).tuple (ht.right.left.tuple (ht.left.cond ht.right.right (Kn.fix _)))

def topseat (_:Word) (a:Chart) : Panel := (false,a.2.2.1,0)
lemma topK : Kn topseat := (Kn.fix _).tuple (Kn.next.right.left.tuple (Kn.fix _))

def tryU (dir:Bool) : Cog := .seq (p.probes true) (etch (upmov dir) (upK dir))
def chase (dir:Bool) : Cog := .loop (gear p.keep p.keepK) (p.tryU dir)
def rise (dir:Bool) : Cog := .seq (etch _ topK) (.seq (p.chase dir) (etch _ (p.summitK dir)))

def downgrade (_:Word) (a:Chart):Panel := (false,a.2.2.1,a.2.2.2-1)
lemma downgrades : Kn downgrade := (Kn.fix _).tuple
         (Kn.next.right.left.tuple Kn.next.right.right.pred)
def dock (p:Shows) (dir:Bool) (x:Word) (a:Chart) : Panel :=
   let (b,v,i):=a.2
   if b then (false,i,if dir then 0 else p.rad.f x (a.1,i))
   else (false,v, if dir then i+1 else i)
lemma dockK (d): Kn (p.dock d) := by
    have ht : Kn (fun (_:Word) (a:Chart)=> a.2):=Kn.next
    cases d
    · exact ht.left.cond ((Kn.fix _).tuple (ht.right.right.tuple
                         (p.rad.runs.comp (Kn.first.tuple ht.right.right))))
                    ((Kn.fix _).tuple ht.right)
    · exact ht.left.cond ((Kn.fix _).tuple (ht.right.right.tuple (Kn.fix _)))
                   ((Kn.fix _).tuple (ht.right.left.tuple ht.right.right.succ))

def highp (_:Word) (a:Chart) : Bool := decide (0<a.2.2.2)
lemma highK : Kn highp := (Kn.fix _).lt Kn.next.right.right
def seeD (dir:Bool) : Cog :=
   .seq (p.probes false) (etch _ (p.dockK dir))
def step : Bool→ Cog
   | true=> .bif (gear _ p.keepK) (p.seeD true) (p.rise true)
   | false=> .bif (gear _ highK) (.seq (etch _ downgrades) (p.seeD false)) (p.rise false)

def repeatQ (x:Word) (a:Chart) := !(p.marked.f x (a.1,a.2.2))
lemma repeatK : Kn p.repeatQ := Kn.bneg _ (p.marked.runs.comp (Kn.first.tuple Kn.next.right))
def spool (b:Bool) : Cog := .loop (gear _ p.repeatK) (p.step b)
def away (b:Bool) : Cog := .seq (p.step b) (p.spool b)
def check (s:Arena) (v:Gem):Bool:= p.marked.f s.l.x (s.q,v.1.1,v.2)

structure Covers (s:Arena) : Prop where
    rate : ∀ v∈s.trees.V,p.rad.f s.l.x (s.q,v.1)=s.trees.broad v
    adm : ∀ v,s.trees.live v → ∀ b,s.l.state s.cost s.b (s.tag v b)
    know : ∀ b v, v∈s.trees.V → ∀ i, i < s.trees.broad v →
           s.acts (p.probes b) (s.tag (v,i) false) (s.touch b v i)

end Shows
end ExactDerandomization.Swirl

end

section

namespace ExactDerandomization.Swirl
open Relay
namespace Shows
variable {p:Shows} {s:Arena} (u:p.Covers s)

def promote (_:Fir) (b:Bool) (v:Dot)(w:Dot) :Gem := (w,if b then v.1+1 else v.1)

def counted (s:Arena) (b:Bool) (v:Dot):Site :=
   match s.trees.up v with
   | none => s.tag (v,s.trees.broad v) false
   | some w=> s.tag (promote s.trees b v w) true

def rer (s:Arena) (b:Bool) (v:Dot):Gem :=
   match s.trees.up v with
   | none=> (v, if b then 0 else s.trees.broad v)
   | some w=>promote s.trees b v w

namespace Covers
include u

lemma stayst {v:Dot} {i} (h:v∈s.trees.V) (hi:i ≤ s.trees.broad v) (b:Bool) :
    s.l.state s.cost s.b (s.tag (v,i) b):=u.adm _ ⟨h,hi⟩ b

lemma truekeep {x} (hi : x.2 < s.trees.broad x.1) (h:x.1∈s.trees.V) :
    (gear p.keep p.keepK).f s.l.x (s.q,s.tag x false)=true := by
    rw [gear_at]; simp [keep,ray,u.rate x.1 h,hi]
lemma falsekeep {x : Gem} (hi : x.2=s.trees.broad x.1) (h:x.1∈s.trees.V) :
    (gear p.keep p.keepK).f s.l.x (s.q,s.tag x false)=false := by
    rw [gear_at]; simp [keep,ray,u.rate x.1 h,hi]
omit u in
lemma stopkeep (x:Gem) :
    (gear p.keep p.keepK).f s.l.x (s.q,s.tag x true)=false := by
    rw [gear_at]; simp [keep]
lemma powered {b v w} (hv:v∈s.trees.V) (h:s.trees.up v=some w) (e) :
   s.l.state s.cost s.b (s.tag (promote s.trees b v w) e):= by
    obtain ⟨ha,hb,hc,hd⟩:=s.trees.pairU v hv h
    apply u.stayst ha
    change v.1 < s.trees.broad w at hc
    split <;> omega

set_option maxHeartbeats 2000000 in
lemma sought {v i} (h:v∈s.trees.V) (hi:i ≤ s.trees.broad v)
    (he:∀ w,s.trees.up v=some w → i ≤ w.1) (b:Bool) :
    s.acts (p.chase b) (s.tag (v,i) false) (counted s b v):= by
   induction hi using Nat.decreasingInduction with
   | self=>
     have hp : s.trees.up v=none:=by
        cases hw:s.trees.up v with
        | none=>rfl
        | some w=>
          exfalso
          exact not_lt.mpr (he _ hw) (s.trees.pairU _ h hw).2.1
     rw [counted,hp]; exact .stop (u.falsekeep rfl h) (u.stayst h le_rfl _)
   | of_succ i hi ih=>
     by_cases hv : ∃ w,s.trees.up v=some w ∧ w.1=i
     · obtain ⟨w,hw,rfl⟩:=hv
       rw [counted,hw]
       have hz:= u.know true v h w.1 hi
       have hk : s.touch true v w.1 = s.wait ((true,v.1,w.1):Panel) w.2 := by
          simp [Arena.touch,Fir.probe,Fir.riseQ,hw]
       rw [hk] at hz
       have hn:=u.powered (b:=b) h hw true
       have hy: s.acts (etch _ (upK b))
             (s.wait ((true,v.1,w.1):Panel) w.2)
             (s.tag (promote s.trees b v w) true) :=
          etches _ (upK b) (l:=s.l) (c:=s.cost) (b:=s.b) (d:=s.d) (q:=s.q)
             (i:=((true,v.1,w.1):Panel)) (w:=s.hand w.2) rfl hz.spots.2 hn
       have hp: s.acts (p.chase b) (s.tag (promote s.trees b v w) true)
                           (s.tag (promote s.trees b v w) true):=.stop
                            ((stopkeep (p := p) (s := s)) (promote s.trees b v w)) hn
       exact .more (u.truekeep hi h) (.seq hz hy) hp
     have hg:= u.know true v h i hi
     have hw:s.touch true v i=s.tag (v,i) false:= by
        cases e:s.trees.up v with
        | none=> simp [Arena.touch,Fir.probe,Fir.riseQ,e]
        | some w=>
          have hz : w.1≠i:=fun hf=>hv ⟨_,e,hf⟩
          simp [Arena.touch,Fir.probe,Fir.riseQ,e,hz]
     rw [hw] at hg
     have hk : ∀ w,s.trees.up v=some w → i+1 ≤ w.1:=by
        intro w hw
        have hs:= he _ hw
        have hz : w.1≠i:=fun hf=>hv ⟨_,hw,hf⟩
        omega
     have hz:= ih hk
     refine .more (u.truekeep hi h) (.seq hg ?_) hz
     exact etches _ (upK b) rfl hg.spots.2 hz.spots.1

lemma wished {v i} (h:v∈s.trees.V) (hi:i ≤ s.trees.broad v) (b:Bool):
    s.acts (p.rise b) (s.tag (v,i) false) (s.tag (rer s b v) false):= by
   have he0:= u.sought h (Nat.zero_le _) (i:=0) (fun _ _=>Nat.zero_le _) b
   apply Lot.Mane.seq (etches _ topK rfl (u.stayst h hi false) he0.spots.1)
   refine .seq he0 ?_
   have hu:=he0.spots.2
   cases he:s.trees.up v with
   | none=>
     simp only [counted,he] at hu ⊢
     simp only [rer,he]
     exact etches _ (p.summitK b) (by simp [summit,u.rate v h]) hu (u.stayst h (i:=if b then 0 else s.trees.broad v) (by split <;> omega) false)
   | some w=>
     simp only [counted,he] at hu ⊢
     simp only [rer,he]
     exact etches _ (p.summitK b) rfl hu (u.powered h he false)

def chosen (s:Arena) (b:Bool) (v:Dot) (i:ℕ): Gem:=
   match s.trees.kid v i with
   | none=>(v,if b then i+1 else i)
   | some w=>(w, if b then 0 else s.trees.broad w)
lemma child {v i} (h:v∈s.trees.V) (hi:i < s.trees.broad v) (b:Bool):
    s.acts (p.seeD b) (s.tag (v,i) false) (s.tag (chosen s b v i) false):= by
   have hz:= u.know false v h i hi
   cases he:s.trees.kid v i with
   | none=>
     have hs:s.touch false v i=s.tag (v,i) false:=by simp [Arena.touch,Fir.probe,he]
     rw [hs] at hz
     refine .seq hz ?_
     rw [chosen,he]
     exact etches _ (p.dockK b) rfl hz.spots.2 (u.stayst h (by split <;> omega) _)
   | some w=>
     have hs:s.touch false v i=s.wait ((true,v.1,i):Panel) w.2:=by simp [Arena.touch,Fir.probe,he]
     rw [hs] at hz
     obtain ⟨ha,hb,hc⟩:=s.trees.pairK v h i he
     refine .seq hz ?_
     rw [chosen,he]
     exact etches _ (p.dockK b) (by simp only [dock,← hc,u.rate w ha,ite_true]) hz.spots.2
                            (u.stayst ha (by split <;> omega) _)

lemma forwardx {v} (h:s.trees.live v) :
   s.acts (p.step true) (s.tag v false) (s.tag (s.trees.roll v) false) := by
   rcases v with ⟨v,i⟩
   by_cases hi:i < s.trees.broad v
   · refine .yes (u.truekeep hi h.1) ?_
     rw [show s.trees.roll (v,i)=chosen s true v i from by
       cases hw:s.trees.kid v i <;> simp [Fir.roll,chosen,hi,hw]]
     exact u.child h.1 hi true
   have he : i=s.trees.broad v:=le_antisymm h.2 (by omega)
   refine .no (u.falsekeep he h.1) ?_
   rw [show s.trees.roll (v,i)=rer s true v from by
        cases hw:s.trees.up v <;> simp [Fir.roll,hi,rer,promote,hw]]
   exact u.wished h.1 h.2 true
lemma previousx {v} (h:s.trees.live v) :
   s.acts (p.step false) (s.tag v false) (s.tag (s.trees.fold v) false) := by
   rcases v with ⟨v,i⟩; cases i with
   | zero=>
     refine .no (by rw [gear_at]; simp [highp]) ?_
     rw [show s.trees.fold (v,0)=rer s false v from by
       cases hw:s.trees.up v <;> simp [Fir.fold,rer,promote,hw]]
     exact u.wished h.1 h.2 false
   | succ i=>
     have hs := u.child (i:=i) h.1 h.2 false
     refine .yes (by rw [gear_at]; simp [highp])
       (.seq (etches _ downgrades rfl (u.stayst h.1 h.2 false) hs.spots.1) ?_)
     rw [show s.trees.fold (v,i+1)=chosen s false v i from by
        cases hw:s.trees.kid v i <;> simp [Fir.fold,chosen,hw]]
     exact hs

lemma turnx (b:Bool) {x y} (h:s.trees.march b x y):
   s.acts (p.step b) (s.tag x false) (s.tag y false):=by
   obtain ⟨h,rfl,-⟩:=h; cases b
   · exact u.previousx h
   exact u.forwardx h

omit u in
lemma restNeon (x:Gem) : (gear p.repeatQ p.repeatK).f s.l.x (s.q,s.tag x false) =
                          !(p.check s x):=gear_at _ _ _ _ _ _
lemma flash (b:Bool) {x y} (h:Flare (s.trees.march b) (p.check s) x y):
    s.acts (p.away b) (s.tag x false) (s.tag y false):= by
   induction h with
   | @arrive x y h e=>
     have hy:=u.turnx b h
     exact .seq hy (.stop (by rw [(restNeon (p := p) (s := s)),e]; rfl) hy.spots.2)
   | @climb x v z h e hz ih=>
     unfold away at ih
     cases ih with
     | seq hp hq=>
       exact .seq (u.turnx b h) (.more (by rw [(restNeon (p := p) (s := s)),e]; rfl) hp hq)

end Covers
end Shows
end ExactDerandomization.Swirl

end

section

/-! Cap from bounded tours; constants are continuation tags, not
additional allocations. -/
namespace ExactDerandomization.Swirl
open Relay

lemma Stripe.twain {α} {r s:α→α→Prop} {x l y} (h:Stripe r x l y) (e:Stripe s y l.reverse x):
    Stripe (fun a b=> r a b ∧ s b a) x l y := by
   have he : Stripe (fun a b=>s b a) x l y := by simpa using e.both (w:=fun a b=>s b a) (fun _ _ h=>h)
   clear e
   induction h with
   | run h=> cases he with | run e=> exact .run ⟨h,e⟩
   | hook h _ ih=> cases he with | hook v e=> exact .hook ⟨h,v⟩ (ih e)

structure Rake where
    p : Shows
    flag : Flag
namespace Rake
variable (r:Rake)
abbrev forth := r.p.away true
abbrev back := r.p.away false
abbrev root (s:Arena) (v:Gem) := r.flag.f s.l.x (s.q,s.tag v false)
abbrev pass (s:Arena) (a b: Gem) :=
   s.acts r.forth (s.tag a false) (s.tag b false) ∧
       s.acts r.back (s.tag b false) (s.tag a false)

structure Circuit (s:Arena) (x:Gem) (l:List Gem) : Prop where
   round : Stripe (r.pass s) x l x
   init : r.root s x=true
   others : ∀ y∈l,r.root s y=false

lemma cable {s:Arena} (h:r.p.Covers s) {v:Dot} (hs:v∈s.trees.V) (he:s.trees.up v=none)
   (hm:r.p.check s (v,0)=true) (hz:r.root s (v,0)=true)
   (hk:∀ y:Gem,s.trees.nest v y → r.p.check s y=true → y≠(v,0) → r.root s y=false) :
   ∃ l:List Gem,r.Circuit s (v,0) l ∧ l.Nodup ∧ ∀ y,y∈l ↔
      s.trees.nest v y ∧ r.p.check s y=true ∧ y≠(v,0) := by
   obtain ⟨l,hl,h1,h2,h3⟩:=s.trees.streak hs he _ hm
   have ht (y:Gem) : y∈l ↔ s.trees.nest v y ∧ r.p.check s y=true ∧ y≠(v,0):=by
       rw [List.nodup_cons] at hl
       have h:=h1 y
       grind
   exact ⟨l, ⟨(h2.twain h3).every fun a b ⟨e,g⟩=>⟨h.flash _ e,h.flash _ g⟩,
                   hz,fun a e=>hk a ((ht a).1 e).1 ((ht a).1 e).2.1 ((ht a).1 e).2.2⟩,
                (List.nodup_cons.1 hl).2,ht⟩

def seek (r:Rake) : ℕ→(ℕ → Cog) → Cog → Cog
  | 0,y,n=> .bif r.flag (y 0) n
  | k+1,y,n=> .bif r.flag (y 0) (.seq r.forth (r.seek k (fun i=>y (i+1)) (.seq r.back n)))
inductive Alley (r:Rake) (s:Arena) (rootv:Gem) : Gem→ℕ→Prop
  | home (h:r.root s rootv=true) : Alley r s rootv rootv 0
  | walk {n a b} (h:r.pass s a b) (e:r.root s a=false) (g:Alley r s rootv b n) :
       Alley r s rootv a (n+1)

lemma Alley.ofStripe {r s a x l} (h:Stripe (r.pass s) x l a)
    (hs:r.root s a=true) (ht:r.root s x=false) (he:∀ i∈l,r.root s i=false):
    Alley r s a x (l.length+1):= by
    induction h with
    | run h=> exact .walk h ht (.home hs)
    | hook h e ih=> exact .walk h ht (ih hs (he _ (by simp)) fun i hi=>he i (by simp [hi]))
lemma sounded {s a b j} (h:Alley r s b a j) (n:ℕ) (y:ℕ → Cog) (w:Cog) {u}
    (hy:j≤n→ s.acts (y j) (s.tag b false) u)
    (hw:n<j→ s.acts w (s.tag a false) u) :
    s.acts (seek r n y w) (s.tag a false) u:= by
    induction h generalizing n y w with
    | home h=>
      cases n <;> exact .yes h (hy (Nat.zero_le _))
    | @walk j a b h e g ih=>
      cases n with
      | zero=> exact .no e (hw (by omega))
      | succ n=>
        exact .no e (.seq h.1 (ih n _ _ (fun ht=> hy (by omega)) (fun hz=> .seq h.2 (hw (by omega)))))

def gather (r:Rake) (k:ℕ) (f:ℕ → Cog) : Cog :=
   .seq r.forth (seek r k f (.seq r.back (f k)))

lemma attained {s x l} (h:r.Circuit s x l) (k:ℕ) (f:ℕ → Cog) {u}
   (he:s.acts (f (min l.length k)) (s.tag x false) u):
    s.acts (gather r k f) (s.tag x false) u:= by
   obtain ⟨hr,hi,h1⟩:=h
   cases l with
   | nil=>
      cases hr with
      | run hr=>
        apply Lot.Mane.seq hr.1
        apply r.sounded (.home hi)
        · intro; simpa using he
        intro h; omega
   | cons a l=>
      cases hr with
      | hook hp h=>
        have hv:=Alley.ofStripe h hi (h1 a (by simp)) (fun a e=>h1 a (by simp [e]))
        apply Lot.Mane.seq hp.1
        apply r.sounded hv
        · intro h; simpa [h] using he
        intro h
        exact .seq hp.2 (by simpa [show k≤l.length+1 by omega] using he)

def ply (f: Cog) : ℕ→ Cog→ Cog
   | 0,w=>w
   | n+1,w=>.seq f (ply f n w)
lemma follow {s:Arena} {f a b l} (p:Stripe
               (fun a b=>s.acts f (s.tag a false) (s.tag b false)) a l b) {w u}
   (h:s.acts w (s.tag b false) u) :
    s.acts (ply f (l.length+1) w) (s.tag a false) u:=by
   induction p with
   | run hz=>exact .seq hz h
   | hook hz e ih=>exact .seq hz (ih (by assumption))

def surf (r:Rake) (k:ℕ) (y:ℕ → Cog) (bad:Cog) : Cog :=
   seek r k (fun i=> gather r (k+1) fun m=>
        if m≤k then y (m+1-i) else ply r.back i bad) bad

lemma climbed {s x l} (h:r.Circuit s x l) (k:ℕ) (y:ℕ → Cog) (bad:Cog)
   {u a b i} (hs:l=a++i::b)
   (hy:l.length≤k → s.acts (y (a.length+1)) (s.tag x false) u)
   (hw:k< l.length → s.acts bad (s.tag i false) u) :
   s.acts (r.surf k y bad) (s.tag i false) u:= by
   subst l
   have hh:= h.round.sever
   have ht:= Alley.ofStripe hh.2 h.init (h.others i (by simp)) (fun x h1=>h.others x (by simp [h1]))
   apply r.sounded ht
   · intro hb
     apply r.attained h
     simp only [List.length_append,List.length_cons]
     split
     · next hl=>
       have h1: (a++i::b).length ≤ k:=by simp; omega
       have hp:=hy h1
       convert hp using 1
       have hz : min (a.length+(b.length+1)) (k+1)+1-(b.length+1)=a.length+1:= by omega
       rw [hz]
     · next hl=>
       have he:k < (a++i::b).length:=by simp; omega
       have hu:=follow (hh.2.both (w:=fun a b=>s.acts r.back (s.tag a false) (s.tag b false))
                                      (fun y z h=>h.2)) (hw he)
       simpa using hu
   intro hb; apply hw; simp; omega

def dune (r:Rake) (k i:ℕ) (yes bad:Cog) : Cog :=
   gather r (k+1) fun n=> if n≤ k ∧ 0 < i ∧ i≤n then ply r.forth i yes else bad

lemma chose {s x l} (h:r.Circuit s x l) (k i:ℕ) (yes bad:Cog)
   {u} (hy: (l.length≤ k ∧ 0 < i ∧ i≤l.length) →
             ∃ a b v,l=a++v::b ∧ i=a.length+1 ∧
                               s.acts yes (s.tag v false) u)
   (hw: ¬ (l.length≤ k ∧ 0 < i ∧ i≤l.length) → s.acts bad (s.tag x false) u):
    s.acts (r.dune k i yes bad) (s.tag x false) u:= by
   apply r.attained h
   split
   · next ht=>
     obtain ⟨a,b,v,e,ht1,hp⟩:=hy (by omega)
     subst l; subst i
     exact follow (h.round.sever.1.every (fun y z h=>h.1)) hp
   · next ht=> exact hw (by omega)

end Rake
end ExactDerandomization.Swirl

end

section

namespace ExactDerandomization.Swirl
open Relay Finset

structure Twig where
    V : Finset Dot
    rad : ℕ → ℕ
    goes : Dot →  Dot →  Prop
    pairs : ∀ {x y},goes x y  →  x∈V∧ y∈V∧ y.1 < rad x.1 ∧ x.1 < rad y.1
    aim : ∀ {x y z},goes x y  →  goes x z  →  z=y
    projected : ∀ {x y z},goes x y  →  goes z y  →  z.1=x.1  →  z=x

namespace Twig
noncomputable section
variable (p:Twig)

def sole (f:Dot → Prop) : Option Dot := by
   classical
   exact if h:∃ i,f i then some (Classical.choose h) else none
lemma solely (f:Dot → Prop) (h:∀ i,f i → ∀ j,f j  →  j=i) (i) :
    sole f=some i ↔ f i:=by
   classical
   unfold sole; split
   · next he=> have hh:=Classical.choose_spec he; grind
   next he=> grind

def upward (x:Dot):= sole (p.goes x)
def fromp (y:Dot)(i:ℕ):= sole (fun x=> p.goes x y ∧ x.1=i)

lemma atU {x y}:p.upward x=some y ↔ p.goes x y:= solely _ (fun _ h _ e=>p.aim h e) y
lemma atD {x y i}:p.fromp y i=some x ↔ p.goes x y ∧ x.1=i :=
   solely _ (fun _ ⟨h,e⟩ _ ⟨u,v⟩=>p.projected h u (v.trans e.symm)) _

def tree : Fir where
   V:=p.V
   rad:=p.rad
   up:=p.upward
   kid:=p.fromp
   pairU := fun _ _ _ h=> let u:=p.atU.1 h;
                           ⟨(p.pairs u).2.1,(p.pairs u).2.2.1,(p.pairs u).2.2.2,p.atD.2 ⟨u,rfl⟩⟩
   pairK := fun _ _ _ _ h=>let u:=p.atD.1 h; ⟨(p.pairs u.1).1,p.atU.2 u.1,u.2⟩

lemma probeU {x i y} : p.tree.probe true x i=some y ↔ p.goes x y ∧ y.1=i:= by
   unfold Fir.probe Fir.riseQ
   rw [ite_eq_left rfl]
   cases h:p.tree.up x with
   | none=>
      refine ⟨by simp,fun he=>?_⟩
      have hz : p.tree.up x=some y:=p.atU.2 he.1
      rw [h] at hz; contradiction
   | some w=>
      have hm:=p.atU.1 h
      constructor
      · rintro hp; split at hp
        · next he=> grind
        contradiction
      intro h
      obtain rfl:= p.aim hm h.1
      grind
lemma probeD {x i y} : p.tree.probe false y i=some x ↔ p.goes x y∧ x.1=i:=p.atD

end
end Twig

/-- The finite path-kernel: `after q name val = next_raw_name + 1`, zero for no
edge. Modes 0 = static, 1 = opaque stationary, any other = mobile. Every
operation-dependent guard is generated in LF before calling a lower query. -/
structure Bud where
    rad : Cub (Lore ℕ) ℕ
    mark : Cub (Lore Seat) Bool
    allow : Cub (Lore Seat) Bool
    mode : Cub (Lore ℕ) ℕ
    after : Cub (Lore Seat) ℕ
    beta : Cub (Lore Seat) ℕ
    stem : Bool →  Cub (Lore Seat) ℕ

/-- Root kernel proof data. hand maps addresses to the shared register carrying
that address and a catalyst, not to local pc states. Different hand embeddings
of the same addresses during different invocations are allowed. -/
structure Clay where
   l:Lot
   b:Level
   d:ℕ
   q:ℕ
   cost:ℕ
   raw: Finset ℕ
   cursor: Finset ℕ
   hand: ℕ → ℕ
   echo : ℕ → ℕ → ℕ
   stream : ℕ → ℕ → Bool → ℕ → Option ℕ

namespace Bud
variable (p:Bud) (s:Clay)

abbrev pk (s:Clay)(v i:ℕ) : Lore Seat := (s.q,v,i)
abbrev ready (v i) := p.allow.f s.l.x (pk s v i)

abbrev entry v:= p.mode.f s.l.x (s.q,v)
abbrev nextx (v i) := p.after.f s.l.x (pk s v i)
abbrev code (v i):=p.beta.f s.l.x (pk s v i)
abbrev range0 v:=p.rad.f s.l.x (s.q,v)

def earth:= s.raw ×ˢ s.cursor
lemma walled {x:Dot} : x∈ earth s ↔ x.1∈s.raw ∧ x.2∈s.cursor:=mem_product

def Hill (x y:Dot) :Prop :=
   x∈earth s ∧ y∈earth s ∧ p.ready s x.1 y.1=true ∧
    match p.entry s x.1 with
    | 0=> p.nextx s x.1 0=y.1+1 ∧ x.2=y.2
    | 1=> p.nextx s x.1 (s.echo x.1 x.2)=y.1+1 ∧ x.2=y.2
    | _=> s.stream x.1 (p.code s x.1 y.1) true x.2=some y.2

/-- Canonical toss calls for stationary/moving candidates -/
abbrev poke (b:Bool) (i j:ℕ) := p.stem b |>.f s.l.x (pk s i j)
def motorout (v z:ℕ)(b:Bool)(c:ℕ): Site :=
    match s.stream v z b c with
    | none=> (0,s.hand c)
    | some w=> (1,s.hand w)

def bed (a:Bool) (v i c:ℕ):Site:= Pause ((a,v,i):Panel) (s.hand c)

structure Wall : Prop where
    scaled : ∀ {v i},p.ready s v i=true  →
                    v∈s.raw ∧ i∈s.raw ∧ i<p.range0 s v ∧ v<p.range0 s i
    size : ∀ {v c},v∈s.raw  →  c∈s.cursor  →  ∀ i≤ p.range0 s v,∀ b,s.l.state s.cost s.b (bed s b v i c)
    call : ∀ {v i}, p.ready s v i=true  →  p.entry s v≠0  →  ∀ b,
          let a : Seat:= if b then (v,i) else (i,v)
          s.l.jump s.cost s.b s.d (enc ((false,a):Panel)) (p.poke s b v i)
    upright : ∀ {v i}, p.ready s v i=true  →  p.entry s v=1  →  ∀ x∈s.cursor,∀ b,
         Boots s.l.x s.l.F s.l.P (p.poke s b v i) s.l.P (0,s.hand x) (s.echo v x,s.hand x)
    kite : ∀ {v i}, p.ready s v i=true  →  2 ≤ p.entry s v  →
         p.nextx s v (p.code s v i)=i+1 ∧ ∀ x∈s.cursor,∀ b,
           Boots s.l.x s.l.F s.l.P (p.poke s b v i) s.l.P (0,s.hand x)
                (motorout s v (p.code s v i) b x) ∧
               ∀ y,s.stream v (p.code s v i) b x=some y  →
                   y∈s.cursor ∧ s.stream v (p.code s v i) (!b) y=some x
    unique : ∀ {v i j}, p.ready s v i=true  →  p.ready s v j=true  →  2≤ p.entry s v  →
       ∀ x∈s.cursor,∀ y z, s.stream v (p.code s v i) true x=some y  →
                             s.stream v (p.code s v j) true x=some z  →
                             p.code s v i=p.code s v j

def Wall.twig {s:Clay} {p:Bud} (h:Wall p s) : Twig where
    V:=earth s
    rad:=p.range0 s
    goes:=p.Hill s
    pairs:= fun {_ _} ⟨ha,hb,hc,_⟩=> ⟨ha,hb,(h.scaled hc).2.2⟩
    aim:=by
       rintro x y z ⟨ha,hb,hc,hp⟩ ⟨_,hd,he,hq⟩
       let i:=x.1
       cases ht:p.entry s x.1 with
       | zero=> rw [ht] at hp hq; grind
       | succ n=>
         cases n with
         | zero=> rw [ht] at hp hq; grind
         | succ n=>
           rw [ht] at hp hq
           have hs : 2 ≤ p.entry s x.1:=by omega
           have hu:= h.unique hc he hs x.2 ((walled _).1 ha).2 _ _ hp hq
           have hx: z.1=y.1:=by have h1:= (h.kite hc hs).1; have h2:=(h.kite he hs).1; grind
           apply Prod.ext hx
           grind
    projected:=by
       rintro x y z ⟨ha,hb,hc,hp⟩ ⟨hz,_,he,hq⟩ e
       apply Prod.ext e; rw [e] at hq
       cases ht:p.entry s x.1 with
       | zero=> rw [ht] at hp hq; grind
       | succ n=>
         cases n with
         | zero=> rw [ht] at hp hq; grind
         | succ n=>
           rw [ht] at hp hq
           have hs : 2 ≤ p.entry s x.1:=by omega
           have h1:=((h.kite hc hs).2 x.2 ((walled _).1 ha).2 true).2 _ hp
           have h2:=((h.kite hc hs).2 z.2 ((walled _).1 hz).2 true).2 _ hq
           grind

noncomputable def arena {p:Bud} {s:Clay}(h:p.Wall s):Arena :=
    ⟨s.l,s.b,s.d,s.q,s.cost,h.twig.tree,s.hand⟩

end Bud
end ExactDerandomization.Swirl

end

section

namespace ExactDerandomization.Swirl
open Relay Finset
namespace Bud
variable (p:Bud) (s:Clay)

def invert (b:Bool) (a:Seat) : Seat := if b then a else (a.2,a.1)
lemma invert2 (b:Bool) (x:Seat): invert b (invert b x)=x:=by cases b <;>simp [invert]

def lit (s:Clay) (b:Bool) (a:Seat) (c:ℕ) : Option ℕ :=
    let (v,i):=invert b a
    if p.ready s v i then
      match p.entry s v with
      | 0=> if p.nextx s v 0=i+1 then some c else none
      | 1=> if p.nextx s v (s.echo v c)=i+1 then some c else none
      | _=> s.stream v (p.code s v i) b c
    else none

namespace Wall
variable {p s} (h:Wall p s)
include h

lemma alive {v i c e:ℕ} (hc:c∈s.cursor) :
    p.Hill s (v,c) (i,e) ↔ p.lit s true (v,i) c=some e:=by
   unfold Hill lit; simp only [invert,ite_true]
   by_cases hv:p.ready s v i=true
   · obtain ⟨ha,hb,h1,h2⟩:=h.scaled hv
     rw [ite_eq_left hv]
     cases hk:p.entry s v with
     | zero=>
       by_cases ht:p.nextx s v 0=i+1 <;> simp [hv,walled,ha,hb,hc,ht] ; grind
     | succ k=>
       cases k with
       | zero=> by_cases ht:p.nextx s v (s.echo v c)=i+1 <;>
                      simp [hv,walled,ha,hb,hc,ht] ; grind
       | succ k=>
         simp only [hv,walled,ha,hb,hc,true_and,and_self ]
         constructor
         · intro e; exact e.2
         intro e; exact ⟨(((h.kite hv (by omega)).2 c hc true).2 _ e).1,e⟩
   simp [hv]

lemma hover {v i c e:ℕ} (hc:c∈s.cursor) :
    p.Hill s (v,e) (i,c) ↔ p.lit s false (i,v) c=some e:=by
   unfold Hill lit; simp only [invert,Bool.false_eq_true,ite_false]
   by_cases hv:p.ready s v i=true
   · obtain ⟨ha,hb,h1,h2⟩:=h.scaled hv
     rw [ite_eq_left hv]
     cases hk:p.entry s v with
     | zero=>
       by_cases ht:p.nextx s v 0=i+1 <;> simp [hv,walled,ha,hb,hc,ht] ; grind
     | succ k=>
       cases k with
       | zero=> by_cases ht:p.nextx s v (s.echo v c)=i+1 <;>
                      simp [hv,walled,ha,hb,hc,ht] <;> grind
       | succ k=>
         simp only [hv,walled,ha,hb,hc,true_and,and_self ]
         constructor
         · intro e; exact (((h.kite hv (by omega)).2 _ e.1 true).2 _ e.2).2
         intro e; exact ((h.kite hv (by omega)).2 c hc false).2 _ e
   simp [hv]

lemma auth (b:Bool) {v c:ℕ} (hc:c∈s.cursor) (i:ℕ) :
   h.twig.tree.probe b (v,c) i = (p.lit s b (v,i) c).map (fun j=>(i,j)):=by
   have he(w:Dot): h.twig.tree.probe b (v,c) i=some w ↔
                (p.lit s b (v,i) c).map (fun j=>(i,j))=some w:=by
      rcases w with ⟨w,e⟩
      cases b
      · rw [h.twig.probeD]
        by_cases hk:w=i
        · subst w; change p.Hill s (i,e) (v,c) ∧ _ ↔ _; rw [h.hover hc]; simp
        simp [hk,Ne.symm hk]
      · rw [h.twig.probeU]
        by_cases hk:w=i
        · subst w; change p.Hill s (v,c) (i,e) ∧ _ ↔ _; rw [h.alive hc]; simp
        simp [hk,Ne.symm hk]
   generalize h1:h.twig.tree.probe b (v,c) i=w at *
   generalize h2:(p.lit s b (v,i) c).map (fun j=>(i,j))=z at *
   cases w with
   | none=> cases z with
            | none=>rfl
            | some a=> have := he a; simp_all
   | some a=>
     exact ((he a).1 rfl).symm

lemma again (b:Bool) {v i c w} (hc:c∈s.cursor) (hw:p.lit s b (v,i) c=some w) :
   w∈s.cursor := by
   cases b
   · exact ((walled s).1 ((h.hover hc).2 hw).1).2
   · exact ((walled s).1 ((h.alive hc).2 hw).2.1).2

lemma dusk (b:Bool) {v c:ℕ} (hc:c∈s.cursor) (i:ℕ) :
    (arena h).touch b (v,c) i =
      match p.lit s b (v,i) c with
      | none=> bed s false v i c
      | some e=>bed s true v i e:=by
   unfold Arena.touch
   have he : (arena h).trees.probe b (v,c) i=(p.lit s b (v,i) c).map (fun j=>(i,j)) :=
       h.auth b hc i
   rw [he]
   cases p.lit s b (v,i) c <;> rfl

end Wall
end Bud
end ExactDerandomization.Swirl

end

section

namespace ExactDerandomization.Swirl
open Relay Finset
namespace Bud
variable (p:Bud)

def putter (b:Bool) (_:Word) (a:Lore Panel) : Lore Seat :=
    (a.1,invert b a.2.2)
lemma putK(b):Kn (putter b):= by
   cases b
   · exact Kn.first.tuple (Kn.next.right.right.tuple Kn.next.right.left)
   · exact Kn.first.tuple Kn.next.right
def gate (b:Bool) (x:Word) (a:Lore Panel) : Bool:= p.allow.f x (putter b x a)
def chk (b:Bool) (x:Word) (a:Lore Panel):ℕ :=
     let u:=putter b x a
     p.mode.f x (u.1,u.2.1)
lemma chkK (b):Kn (p.chk b) := p.mode.runs.comp ((putK b).left.tuple (putK b).right.left)

def printx (b:Bool) (x:Word) (a : Lore Panel × ℕ) : Panel :=
    let u:= putter b x a.1
    let i:= p.after.f x (u.1,u.2.1,a.2)
    (if p.chk b x a.1 ≤ 1 then decide (i=u.2.2+1) else decide (a.2=1),
     a.1.2.2)

lemma printK (b): Kn (p.printx b) := by
   have hp := (putK b).comp (Kn.first (β:=ℕ))
   have hg := p.after.runs.comp (hp.left.tuple (hp.right.left.tuple Kn.next))
   exact (((p.chkK b).comp Kn.first).cond_le (Kn.fix _) (hg.eq hp.right.right.succ) (Kn.next.eq (Kn.fix _))).tuple Kn.first.right.right

def pureq (b:Bool) (x:Word) (a:Lore Panel) := p.printx b x (a,0)
lemma pureK (b) : Kn (p.pureq b) := (p.printK b).comp (Kn.identity.tuple (Kn.fix _))

def script (b:Bool) (x:Word) (a:Slip) := (p.stem b).f x (putter b x (a.1,dec a.2))
lemma scriptK (b) : Kn (p.script b) :=
   (p.stem b).runs.comp ((putK b).comp (Kn.first.tuple (Kn.unpack.comp Kn.next)))

def heedx (b:Bool) (x:Word) (a:Drain) : Site :=
   Pause (p.printx b x ((a.1.1,dec a.1.2),a.2.1)) a.2.2
lemma heedK (b): Kn (p.heedx b) := (Kn.wash.comp ((p.printK b).comp
    ((Kn.first.left.tuple (Kn.unpack.comp Kn.first.right)).tuple Kn.next.left))).tuple Kn.next.right

def tackle (b:Bool):Cog :=
   .bif (gear (p.gate b) (p.allow.runs.comp (putK b)))
         (.bif (gear (fun x a=> decide (p.chk b x a=0)) ((p.chkK b).eq (Kn.fix _)))
           (etch (p.pureq b) (p.pureK b))
           (.toss ⟨_,p.scriptK b⟩ ⟨_,p.heedK b⟩))
         (.edit ⟨_,Kn.next⟩)

def showall : Shows:= ⟨p.rad,p.mark,p.tackle⟩

namespace Wall
variable {s p} (h:Wall p s)

set_option maxHeartbeats 800000 in
lemma handle {v c} (hv:v∈s.raw) (hc:c∈s.cursor) {i} (hi:i<p.range0 s v)
   (b:Bool):
   (arena h).acts (p.tackle b) (bed s false v i c) ((arena h).touch b (v,c) i):= by
   let a:Panel:=(false,v,i)
   let z:= invert b a.2
   have ha:=h.size hv hc i hi.le false
   rw [h.dusk b hc]
   have hz : z.1=(invert b (v,i)).1∧ z.2=(invert b (v,i)).2:=⟨rfl,rfl⟩
   have hg : (gear (p.gate b) (p.allow.runs.comp (putK b))).f s.l.x (s.q,bed s false v i c)=
                               p.ready s z.1 z.2 := gear_at ..
   have hy : p.chk b s.l.x (s.q,a)=p.entry s z.1:=rfl
   have hm : (gear (fun x a=> decide (p.chk b x a=0)) ((p.chkK b).eq (Kn.fix 0))).f
             s.l.x (s.q, bed s false v i c)=decide (p.entry s z.1=0):=gear_at ..
   by_cases ht:p.ready s z.1 z.2=true
   · apply Lot.Mane.yes (hg.trans ht)
     have ht' := ht
     dsimp only [z,a] at ht'
     cases he:p.entry s z.1 with
     | zero=>
       apply Lot.Mane.yes (by rw [hm,he]; rfl)
       by_cases he0:p.nextx s z.1 0=z.2+1
       · have hu : p.lit s b (v,i) c=some c:=by
             unfold lit; simp only [ht',ite_true]
             change (match p.entry s z.1 with | 0=> _ | 1=>_ | _=>_)=_
             rw [he]; exact ite_eq_left he0
         rw [hu]
         refine etches _ _ ?_ ha (h.size hv hc i hi.le true)
         change p.printx b s.l.x ((s.q,a),0)=(true,v,i)
         dsimp only [printx]; rw [hy,he,ite_eq_left (by omega)]
         change (decide (p.nextx s z.1 0=z.2+1),v,i)=(true,v,i)
         simp [he0]
       · have hu : p.lit s b (v,i) c=none:=by
             unfold lit; simp only [ht',ite_true]
             change (match p.entry s z.1 with | 0=> _ | 1=>_ | _=>_)=_
             rw [he]; exact ite_eq_right he0
         rw [hu]
         refine etches _ _ ?_ ha ha
         change p.printx b s.l.x ((s.q,a),0)=(false,v,i)
         dsimp only [printx]; rw [hy,he,ite_eq_left (by omega)]
         change (decide (p.nextx s z.1 0=z.2+1),v,i)=(false,v,i); simp [he0]
     | succ n=>
       apply Lot.Mane.no (by rw [hm,he]; simp)
       have hd:=h.call ht (show p.entry s z.1≠0 by omega) b
       have hc1 : s.l.jump s.cost s.b s.d (bed s false v i c).1 (p.poke s b z.1 z.2):=by
          cases b <;> exact hd
       have hc2:p.script b s.l.x (s.q, (bed s false v i c).1)=p.poke s b z.1 z.2:=by
          unfold script; simp [bed,Pause]; rfl
       have hc3 (t w:ℕ) : p.heedx b s.l.x ((s.q,(bed s false v i c).1),(t,w)) =
                                  Pause (p.printx b s.l.x ((s.q,a),t)) w:=by simp [heedx,a,bed,Pause]
       cases n with
       | zero=>
         let t:=s.echo z.1 c
         have hh:= h.upright ht he c hc b
         by_cases hb:p.nextx s z.1 t=z.2+1
         · have hu:p.lit s b (v,i) c=some c:=by
             unfold lit; simp only [ht',ite_true]
             change (match p.entry s z.1 with | 0=>_ | 1=>_ | _=>_)=_
             rw [he]; exact ite_eq_left hb
           have hs:p.printx b s.l.x ((s.q,a),t)=(true,v,i):=by
              dsimp only [printx]; rw [hy,he,ite_eq_left (by omega)]
              change (decide (p.nextx s z.1 t=z.2+1),v,i)=(true,v,i); simp [hb]
           rw [hu]; exact .toss hc2 ((hc3 t (s.hand c)).trans (congrArg (fun n=>Pause n (s.hand c)) hs)) ha (h.size hv hc i hi.le true) hc1 hh
         have hu:p.lit s b (v,i) c=none:=by
             unfold lit; simp only [ht',ite_true]
             change (match p.entry s z.1 with | 0=>_ | 1=>_ | _=>_)=_
             rw [he]; exact ite_eq_right hb
         have hs:p.printx b s.l.x ((s.q,a),t)=(false,v,i):=by
              dsimp only [printx]; rw [hy,he,ite_eq_left (by omega)]
              change (decide (p.nextx s z.1 t=z.2+1),v,i)=(false,v,i); simp [hb]
         rw [hu]; exact .toss hc2 ((hc3 t (s.hand c)).trans (congrArg (fun n=>Pause n (s.hand c)) hs)) ha ha hc1 hh
       | succ n=>
         have hh2 : 2 ≤ p.entry s z.1:=by omega
         have hh:= (h.kite ht hh2).2 c hc b
         have hQ:p.lit s b (v,i) c=s.stream z.1 (p.code s z.1 z.2) b c:=by
             unfold lit; simp only [ht',ite_true]
             change (match p.entry s z.1 with | 0=>_ | 1=>_ | _=>_)=_
             rw [he]
             rfl
         have hh1:=hh.1; unfold motorout at hh1
         rw [hQ]
         cases he0:s.stream z.1 (p.code s z.1 z.2) b c with
         | none=>
           have hs:p.printx b s.l.x ((s.q,a),0)=(false,v,i):=by
              dsimp only [printx]; rw [hy,he,ite_eq_right (show ¬ n+1+1 ≤ 1 by omega)]
              rfl
           rw [he0] at hh1; exact .toss hc2 ((hc3 0 (s.hand c)).trans (congrArg (fun n=>Pause n (s.hand c)) hs)) ha ha hc1 hh1
         | some w=>
           have hs:p.printx b s.l.x ((s.q,a),1)=(true,v,i):=by
              dsimp only [printx]; rw [hy,he,ite_eq_right (show ¬ n+1+1 ≤ 1 by omega)]
              rfl
           rw [he0] at hh1
           exact .toss hc2 ((hc3 1 (s.hand w)).trans (congrArg (fun n=>Pause n (s.hand w)) hs)) ha (h.size hv (hh.2 _ he0).1 i hi.le true) hc1 hh1
   have hx : p.ready s z.1 z.2=false := by simp_all
   apply Lot.Mane.no (hg.trans hx)
   have hu:p.lit s b (v,i) c=none:=by unfold lit; apply ite_eq_right ht
   rw [hu]; exact .edit rfl ha ha

theorem yields : p.showall.Covers (arena h) := by
   refine ⟨fun _ _=>rfl,?_,?_⟩
   · rintro ⟨⟨v,c⟩,i⟩ ⟨hv,ht⟩ b
     obtain ⟨hv,hc⟩:= (walled _).1 hv
     exact h.size hv hc i ht b
   rintro b ⟨v,c⟩ h0 i hi
   obtain ⟨hv,hc⟩:= (walled _).1 h0
   exact h.handle hv hc hi b

end Wall
end Bud
end ExactDerandomization.Swirl

end

end OAI