import OAI.Computability.Logspace.DyadicArithmetic

namespace OAI

/-!
Bounded query programs with explicit scratch space and finite-margin guarantees.

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

set_option autoImplicit true

section

/-! cost calculus for prefix recipes. -/
namespace ExactDerandomization.Fret
open Relay Counter Rill Analysis Finset
abbrev unitB (d:ℕ):ℝ:=(2:ℝ)^d
abbrev massB (r d:ℕ):ℝ:= (2:ℝ)^(r*d)
lemma unit1 (d):1 ≤ unitB d:=one_le_pow₀ (by norm_num)
lemma mass1(r d):1 ≤ massB r d:= unit1 _
lemma mass0(r d):0< massB r d:= by unfold massB; positivity
lemma swellB {c d:ℕ}(h:1 ≤ d) : (c:ℝ)< massB c d:= by
    have h1: c<2^c:=by have he:=growing c; omega
    have hh:= lt_of_lt_of_le h1
            (Nat.pow_le_pow_right Nat.zero_lt_two (show c  ≤  c*d by nlinarith))
    unfold massB; exact_mod_cast hh
lemma mass_mul (r k d):massB (r+k) d=massB r d*massB k d:=by unfold massB; rw [add_mul,pow_add]
lemma mass_mono {r k:ℕ}(h:r ≤ k)(d:ℕ):massB r d ≤ massB k d:=by
    unfold massB; gcongr ;norm_num

structure Knob where
    height:Cub ℕ ℕ
    bank:Cub ℕ ℕ
    store:Cub ℕ ℕ

def Align (p:Port)(k:Knob) := p.OK ∧ k.height.f p.l.x p.info=p.d ∧ k.bank.f p.l.x p.info=2^p.d
def Live (p:Port)(k:Knob)(T:ℕ) := 2^T  ≤  k.store.f p.l.x p.info

def Ears (p:Port)(c T i:ℕ)(f:Cog)(v:ℝ) :=
   p.Tells f c T (v / massB i p.d)
lemma amplitude {p:Port} {c T i f v}(h:Ears p c T i f v): |v| ≤  massB i p.d:= by
    obtain ⟨w,h,-⟩:=h
    obtain ⟨hb,-⟩:=h
    rw [abs_div,abs_of_pos (mass0 ..),div_le_one (mass0 ..)] at hb
    exact hb
lemma fewer {p:Port}{f c H w F}(h:p.Feeds f c H w F){D T}(he:1 ≤ c)(hk:c  ≤ D)(hv:T ≤  H):
    p.Feeds f D T w F :=
   ⟨⟨h.1.1,fun t hi=>h.1.2 t (hi.trans hv)⟩,
       ⟨fun t hi=>(h.2.digits t (hi.trans hv)).mono hk he⟩⟩
lemma supply {p:Port}{f c T i v}(h:Ears p c T i f v){D H}(he:1 ≤ c)(hk:c ≤ D)(hp:H  ≤  T):
    Ears p D H i f v:=by
    obtain ⟨w,h⟩:=h
    exact ⟨w,fewer h he hk hp⟩

def amount (p:Knob)(i:ℕ) (x:Word)(v:ℕ):ℕ:=(p.bank.f x v)^i
lemma amountK (p:Knob)(i): Kn (amount p i):= Kn.power _ p.bank.runs
lemma counted {p:Port}{k}(h:Align p k)(i):
    (amount k i p.l.x p.info:ℝ)=massB i p.d:=by
    rw [amount,h.2.2,massB,Nat.mul_comm,pow_mul]; push_cast; rfl
def scaleC (k:Knob)(i:ℕ) (x:Word)(v:ℕ):Coin:=Coin.ofZ (amount k i x v)
lemma scaleK(k i): Kn (scaleC k i):=Coin.ofK (amountK k i).ZofN
lemma scalen {p:Port}{k}(h:Align p k)(i):(scaleC k i p.l.x p.info).v=massB i p.d:=by
    rw [scaleC,Coin.ofv]; push_cast; exact counted h i

structure Bid where
    gate:Coin×Coin → Coin
    gn:Kn (fun (_:Word) a=>gate a)
    truef:ℝ → ℝ → ℝ

namespace Bid

variable (p:Bid)
abbrev arm := ℕ×Coin×Coin
def remote (s:Knob)(i j o:ℕ)(x:Word)(a:arm):Coin :=
   let A:=Coin.mult a.2.1 (scaleC s i x a.1)
   let B:=Coin.mult a.2.2 (scaleC s j x a.1)
   Coin.mult (p.gate (A,B)) (Coin.inv (scaleC s o x a.1))
lemma remoteK (s i j o) : Kn (p.remote s i j o):= by
    have hp:Kn (fun (_:Word)(a:arm)=>a.1):=Kn.first
    have ha:=Coin.multK Kn.next.left ((scaleK s i).comp hp)
    have hb:=Coin.multK Kn.next.right ((scaleK s j).comp hp)
    exact Coin.multK (p.gn.comp (ha.tuple hb)) (Coin.invK ((scaleK s o).comp hp))

structure Fit (e i j:ℕ) : Prop where
   goodC:∀ a b,(p.gate (a,b)).v=p.truef a.v b.v
   sturdy:∀ {d:ℕ},1 ≤ d  →  ∀ {x y z w:ℝ},
        |x| ≤ 2*massB i d  →  |y| ≤  2*massB j d  →  |z| ≤ 2*massB i d  →  |w| ≤ 2*massB j d  →
             |p.truef x y-p.truef z w|  ≤  massB e d*(|x-z|+|y-w|)

def uPair (p:Bid)(k:Knob)(i j o e:ℕ)(f g:Cog):Meld :=
   let M:=e+i+j+6
   { P:={ n:=fun _=>⟨_,Kn.fix 1⟩, route:=fun _=>⟨_,Kn.first⟩,
          margin:=⟨fun x a=>M*k.height.f x a, (Kn.fix _).times k.height.runs⟩,
          scans:=fun b=> if b then f else g }
     f:=⟨_,p.remoteK k i j o⟩ }

lemma behold {x y:ℝ}{d :ℕ}(s:0< d) (e i j o:ℕ) (u:p.Fit e i j)
    (he:|x| ≤ massB i d)(ht:|y| ≤ massB j d)
    {a b:ℝ}(hi:|a-x/massB i d| ≤ 1)(hk:|b-y/massB j d| ≤ 1):
       |p.truef (a*massB i d) (b*massB j d)/massB o d - p.truef x y/massB o d|  ≤
          massB (e+i+j) d*(|a-x/massB i d|+|b-y/massB j d|):=by
    let I:=massB i d; let J:=massB j d
    have hh1:=mass0 i d; have hh2:=mass0 j d
    let v:= |a-x/I|; let w:=|b-y/J|
    have h1: |a*I-x|=I*v:=by
       unfold I v; rw [show a*I-x=I*(a-x/I) from by unfold I; field_simp]
       rw [abs_mul,abs_of_pos hh1]
    have h2: |b*J-y|=J*w:= by
       have he':b*J-y=J*(b-y/J):=by unfold J; field_simp
       rw [he',abs_mul]; exact congrArg (fun t=> t*w) (abs_of_pos hh2)
    have ha: |a*I|  ≤ 2*I := by
       change v ≤ 1 at hi; change 0<I at hh1; change |x| ≤ I at he
       have hh:= abs_add_le (a*I-x) x
       rw [sub_add_cancel] at hh; nlinarith
    have hb:|b*J| ≤ 2*J:=by
       change w ≤ 1 at hk; change 0<J at hh2; change |y| ≤ J at ht
       have hh:= abs_add_le (b*J-y) y; rw [sub_add_cancel] at hh; nlinarith
    have hz:=u.sturdy s ha hb (le_trans he (by linarith)) (le_trans ht (by linarith))
    rw [←sub_div,abs_div,abs_of_pos (mass0 o d)]
    apply le_trans (div_le_self (abs_nonneg _) (mass1 o d))
    apply le_trans hz
    rw [h1,h2, mass_mul,mass_mul]
    have ht : 1 ≤ I:= mass1 ..; have hp:1 ≤ J:=mass1 ..
    change massB e d*(I*v+J*w)  ≤  massB e d*I*J*(v+w)
    rw [show massB e d*I*J*(v+w)=massB e d*(I*J*(v+w)) by ring]
    apply mul_le_mul_of_nonneg_left _ (mass0 e d).le
    have hv:0 ≤ I*v:=mul_nonneg (by unfold I; positivity) (abs_nonneg _)
    have hx0:0 ≤ J*w:=mul_nonneg (by unfold J; positivity) (abs_nonneg _)
    nlinarith

abbrev joinCost (e i j c:ℕ):= e+i+j+6+100+c
lemma joint {s:Port}{k i j o e c H f g V X} (h: Align s k) (he:p.Fit e i j) (hc:1 ≤  c)
   (h1:Ears s c (H+(e+i+j+6)*s.d) i f V)(h2:Ears s c (H+(e+i+j+6)*s.d) j g X)
   (hv:|p.truef V X| ≤ massB o s.d) :
   Ears s (powder (Oven.price (joinCost e i j c))) H o (p.uPair k i j o e f g).cooked (p.truef V X):= by
   have ha:=amplitude h1; have hb:=amplitude h2
   obtain ⟨w,h1⟩:=h1; obtain ⟨b,h2⟩:=h2
   let d:=s.d; have hd:1 ≤ s.d:=h.1.1
   let q:=p.uPair k i j o e f g
   let f0:Rill.EV:=fun t _=> if t then V/massB i d else X/massB j d
   let g0:Rill.DW:=fun t _=> if t then w else b
   let C:=joinCost e i j c
   have hC:C≥100∧ c ≤ C:=by unfold C joinCost; omega
   have hM : q.P.margin.f s.l.x s.info=(e+i+j+6)*s.d:=by simp [q,uPair,h.2.1]
   have he0:q.P.Thaw s C H g0 f0:=by
      refine ⟨hC.1,h.1,?_,?_,?_⟩
      · rw [hM]; unfold C joinCost; exact Nat.mul_le_mul_right s.d (by omega)
      · intro b; change 1<2^(C*s.d); have hz:=growing (C*s.d); nlinarith
      intro b i hi; cases b
      · have hu: q.P.scans false=g:=by simp [q,uPair]
        rw [hu, Oven.ext,hM]; exact fewer h2 hc hC.2 le_rfl
      · have hu:q.P.scans true=f:=by simp [q,uPair]
        rw [hu,Oven.ext,hM]; exact fewer h1 hc hC.2 le_rfl
   have hl : q.Lip s (massB (e+i+j) s.d) (p.truef V X/massB o s.d) f0:=by
      refine ⟨by rw [abs_div,abs_of_pos (mass0 ..)]; exact (div_le_one (mass0 ..)).2 hv,
           mass1 ..,?_,fun x y hs hz=>?_⟩
      · rw [hM]; let n:=e+i+j
        change massB n s.d*4*3 ≤ massB (n+6) s.d
        rw [mass_mul n 6]; have hh : 12  ≤ massB 6 s.d:=by
           unfold massB
           calc
              (12:ℝ)  ≤  2^(6:ℕ):=by norm_num
              _ ≤ _:=pow_le_pow_right₀ (by norm_num) (by omega)
        have hp:=mass0 n s.d; rw [mul_assoc]; exact mul_le_mul_of_nonneg_left (by linarith) hp.le
      · have hx:q.tally s f0 true=V/massB i s.d:=by simp [q,Meld.tally,Oven.labels,uPair,f0,d]
        have ht:q.tally s f0 false=X/massB j s.d:=by simp [q,Meld.tally,Oven.labels,uPair,f0,d]
        rw [hx] at hs; rw [ht] at hz; rw [hx,ht]
        simp only [q,uPair,remote,Coin.mul0,Coin.inv0,he.goodC,scalen h,← div_eq_mul_inv]
        exact behold _ hd _ _ _ _ he ha hb hs hz
   exact ⟨_,q.stream s he0 hl⟩
end Bid

end ExactDerandomization.Fret

end

section

namespace ExactDerandomization.Fret
open Relay Counter Rill

inductive Doop where
  | plus| minus| prod| lesser| greater| flip
deriving DecidableEq

namespace Doop

def gate : Doop  →  Coin×Coin  →  Coin
   | .plus=>fun p=> Coin.join p.1 p.2
   | .minus=>fun p=> Coin.join p.1 (Coin.neg p.2)
   | .prod=>fun p=> Coin.mult p.1 p.2
   | .lesser=>fun p=> Coin.minimum p.1 p.2
   | .greater=>fun p=> Coin.maximum p.1 p.2
   | .flip => fun p=> Coin.inv (Coin.maximum p.1 (Coin.ofZ 1))

lemma gateK (p:Doop):Kn (fun (_:Word) a=> p.gate a):= by
   cases p
   · exact Coin.addaK Kn.first Kn.next
   · exact Coin.addaK Kn.first (Coin.negK Kn.next)
   · exact Coin.multK Kn.first Kn.next
   · exact Coin.minK Kn.first Kn.next
   · exact Coin.maxK Kn.first Kn.next
   exact Coin.invK (Coin.maxK Kn.first (Kn.fix (Coin.ofZ 1)))

noncomputable def val : Doop  →  ℝ → ℝ → ℝ
   | .plus=>fun x y=>x+y
   | .minus=>fun x y=>x-y
   | .prod=>fun x y=>x*y
   | .lesser=> fun x y=> min x y
   | .greater=> fun x y=>max x y
   | .flip=> fun x _=>(max x 1)⁻¹
noncomputable def ration(p:Doop):Bid:=⟨p.gate,p.gateK,p.val⟩
def fast (i j:ℕ) := i+j+2
lemma down_clip (x y:ℝ) : |(max x 1)⁻¹-(max y 1)⁻¹| ≤ |x-y| := by
   let a:= max x 1; let b:=max y 1
   have ha:1  ≤  a:=le_max_right ..
   have hb:1 ≤  b:=le_max_right ..
   have he:a⁻¹-b⁻¹=(b-a)/(a*b):=by field_simp
   have hv : |b-a| ≤ |x-y|:=by
      unfold b a; grind
   change |a⁻¹-b⁻¹| ≤ _
   rw [he,abs_div,abs_of_nonneg (show 0≤a*b by nlinarith)]
   exact le_trans (div_le_self (abs_nonneg _) (by nlinarith)) hv
lemma legit (p:Doop)(i j):p.ration.Fit (fast i j) i j:=by
   refine ⟨fun a b=>?_,fun {d} he {x y z t} hx hy hz ht=>?_⟩
   · cases p <;> simp [ration,gate,val,sub_eq_add_neg]
   let I:=massB i d; let J:=massB j d; let K:=massB (fast i j) d
   have h1:1 ≤ I:=mass1 ..; have h2:1 ≤ J:=mass1 ..
   have hu:2 ≤ massB 2 d:=le_of_lt (by simpa using swellB (c:=2) he)
   have hi : 2*I  ≤  K :=by unfold K fast; rw [mass_mul,mass_mul]; change 2*I ≤ I*J*_; nlinarith [mul_le_mul_of_nonneg_left hu (show 0≤I*J by nlinarith)]
   have hj : 2*J  ≤  K :=by unfold K fast; rw [mass_mul,mass_mul]; change 2*J ≤ I*J*_; nlinarith [mul_le_mul_of_nonneg_left hu (show 0≤I*J by nlinarith)]
   let a:=|x-z|; let b:=|y-t|
   have ha:0 ≤ a:=abs_nonneg _; have hb:0 ≤ b:=abs_nonneg _
   have hg:a+b ≤ K*(a+b):=by nlinarith
   cases p
   · change |x+y-(z+t)| ≤ K*(a+b); rw [show _-_=x-z+(y-t) by ring]; exact (abs_add_le ..).trans hg
   · change |x-y-(z-t)| ≤ K*(a+b); rw [show _-_=x-z-(y-t) by ring]; exact (abs_sub _ _).trans hg
   · change |x*y-z*t| ≤ K*(a+b)
     have he1:|x-z| *|y| ≤ a*K:=mul_le_mul_of_nonneg_left (hy.trans hj) ha
     have he2:|y-t| *|z| ≤ b*K:=mul_le_mul_of_nonneg_left (hz.trans hi) hb
     rw [show x*y-z*t=(x-z)*y+(y-t)*z by ring]
     apply le_trans (abs_add_le ..)
     rw [abs_mul,abs_mul]; nlinarith
   · apply le_trans _ hg; simp only [val,ration]; dsimp only [a,b]; grind
   · apply le_trans _ hg; simp only [val,ration]; dsimp only [a,b]; grind
   · exact (down_clip x z).trans ((le_add_of_nonneg_right hb).trans hg)

lemma geom (p:Doop) (i j d:ℕ) (h:0<d) {x y:ℝ}
   (hx: |x| ≤ massB i d)(hy:|y| ≤ massB j d):
   |p.val x y| ≤ massB (fast i j) d:=by
   let I:=massB i d; let J:=massB j d
   let K:=massB 2 d
   have hs:2 ≤ K:=le_of_lt (by simpa [K] using swellB (c:=2) h)
   have hi:1 ≤ I:=mass1 ..; have hj:1 ≤ J:=mass1 ..
   unfold fast; rw [mass_mul, mass_mul]
   change |p.val x y| ≤ I*J*K
   change |x| ≤ I at hx; change |y| ≤ J at hy
   have hu := mul_le_mul_of_nonneg_left hs (show 0≤I*J by nlinarith)
   have hh: |x|+|y| ≤ I*J*K:=by nlinarith
   cases p
   · exact (abs_add_le ..).trans hh
   · exact (abs_sub ..).trans hh
   · change |x*y| ≤ _; rw [abs_mul]
     nlinarith [mul_le_mul hx hy (abs_nonneg _) (show 0 ≤ I by linarith)]
   · refine le_trans ?_ hh; simp [val,min_def]; split <;> have :=abs_nonneg y <;> have := abs_nonneg x <;> linarith
   · refine le_trans ?_ hh; simp [val,max_def]; split <;> have :=abs_nonneg y <;> have := abs_nonneg x <;> linarith
   · change |(max x 1)⁻¹| ≤ _
     have hc:1  ≤  max x 1:=le_max_right ..
     rw [abs_inv,abs_of_nonneg (by linarith)]
     exact le_trans (inv_le_one_of_one_le₀ hc) (by nlinarith)

end Doop

abbrev CoinQuery := ℕ×ℕ

namespace Brick
def center (p:Knob) (f:Cub CoinQuery Coin) (i:ℕ)(x:Word)(a:Plot):Coin :=
   let q:History:=dec a.1
   let u:=p.store.f x q.1
   let s:=Coin.ofZ ((min u (2^q.2):ℕ):ℤ)
   Coin.mult s (Coin.mult (f.f x (q.1,a.2.2)) (Coin.inv (scaleC p i x q.1)))

set_option maxHeartbeats 1000000 in
lemma centerK (p f i):Kn (center p f i):=by
   have h:Kn (fun (_:Word)(a:Plot)=> (dec a.1:History)):=Kn.unpack.comp Kn.first
   have hz:=Coin.ofK ((Kn.cap (p.store.runs.comp h.left) (Kn.fix 2) h.right).ZofN)
   exact Coin.multK hz (Coin.multK (f.runs.comp (h.left.tuple Kn.next.right))
                                  (Coin.invK ((scaleK p i).comp h.left)))

def solop (p:Knob) (f:Cub CoinQuery Coin)(i:ℕ):Cog:=
   .edit ⟨fun x a=>(codeQ (Coin.floor0 (center p f i x a)),a.2.2),
      (codeK (Coin.floorK (centerK p f i))).tuple Kn.next.right⟩
def solo (p:Knob)(f:Cub CoinQuery Coin)(i:ℕ):Cog:=liftarm (solop p f i)
def tapeR (p:Knob)(f:Cub CoinQuery Coin)(i:ℕ)(s:Port)(t:ℕ):ℤ:=
   Coin.floor0 (center p f i s.l.x (postcard s.info t,0,s.src))

lemma each0 (p:Knob)(f:Cub CoinQuery Coin)(i:ℕ)(s:Port)(H)(ha:Align s p)
   (hl:Live s p H){v}(hv:(f.f s.l.x (s.info,s.src)).v=v)
   (he:|v| ≤ massB i s.d):
   s.Feeds (solo p f i) (powder 100) H (tapeR p f i s) (v/massB i s.d):=by
   apply lifting ha.1 (by omega)
   · intro t ht
     refine .edit rfl (s.stale ha.1 t _ (by omega)) (s.alone ha.1 t 100 ?_ ?_)
     · omega
     have h1:=lb_mono (rangeQ (tapeR p f i s t))
     rw [show lb 31=5 by rfl] at h1; omega
   refine ⟨by rw [abs_div,abs_of_pos (mass0 ..)]; exact (div_le_one (mass0 ..)).2 he,
              fun t ht=>?_⟩
   let u:=tapeR p f i s t
   have hg:=Coin.floorok (center p f i s.l.x (postcard s.info t,0,s.src))
   have hz : 2^t  ≤  p.store.f s.l.x s.info:= le_trans (Nat.pow_le_pow_right Nat.zero_lt_two ht) hl
   let g:= center p f i s.l.x (postcard s.info t,0,s.src)
   change (u:ℝ) ≤ g.v ∧ g.v ≤ (u:ℝ)+1 at hg
   have hp:g.v=(2:ℝ)^t*(v/massB i s.d):=by
       unfold g center; simp only [postcard,Wire.eq,Coin.mul0,Coin.ofv,Coin.inv0,hv,scalen ha,
                div_eq_mul_inv]; push_cast
       rw [min_eq_right (by exact_mod_cast hz)]
   rw [hp] at hg
   rw [abs_le]; unfold u at hg; constructor <;>linarith

end Brick
end ExactDerandomization.Fret

end

section

namespace ExactDerandomization.Fret
open Relay Counter Rill Analysis Finset

structure Branch where
    n : Cub ℕ ℕ
    route : Cub (ℕ×ℕ) ℕ
    k : Cub ℕ ℕ
    e : ℕ

namespace Branch
variable (p:Branch)
def port (s:Port)(i:ℕ):Port := {s with info:=p.route.f s.l.x (s.info,i)}
abbrev S (s:Port) := range (p.n.f s.l.x s.info)
abbrev key (s: Port):=p.k.f s.l.x s.info

def bowl (f:Cog): Survey := ⟨p.n,p.k,p.route,f⟩

structure Trust (s:Port)(i:ℕ)(V:ℕ→ℝ)(c H:ℕ)(f:Cog):Prop where
    cheaply : p.n.f s.l.x s.info < (2:ℕ)^(p.e*s.d)
    tick :∀ j∈p.S s,Ears (p.port s j) c H i f (V j)

lemma lease {s:Port}{V H c i f}(h:p.Trust s i V c H f)(hc:1 ≤ c)(ho:s.OK):
    Ears s (powder (Survey.priceB (c+p.e+100))) H i (p.bowl f).poll (rank (p.S s) V (p.key s)):=by
   classical
   have hh(j): ∃ w,j∈p.S s → (p.port s j).Feeds f c H w (V j/massB i s.d):=by
       by_cases ht:j∈p.S s
       · obtain ⟨w,hx⟩:=h.tick j ht; exact ⟨w,fun _=>hx⟩
       exact ⟨fun _=>0,fun hz=> (ht hz).elim⟩
   choose w hw using hh
   let u:=p.bowl f
   let W:= fun (j:ℕ)=> V j/massB i s.d
   have hz : u.Clue s (c+p.e+100) H W w:= by
      refine ⟨by omega,ho,?_ ,fun j hj=>fewer (hw j (mem_range.2 hj)) hc (by omega) le_rfl⟩
      apply h.cheaply.trans_le (Nat.pow_le_pow_right Nat.zero_lt_two ?_)
      gcongr; omega
   let v:=massB i s.d
   have hs:rank (p.S s) W (p.key s)=rank (p.S s) V (p.key s)/v:=by
      have hm:W=(fun j=>v⁻¹*V j):=funext fun _=> by unfold v W; ring
      rw [hm,scaled_rank (by unfold v; positivity)]; ring
   have ht: Ears s (powder (Survey.priceB (c+p.e+100))) H i u.poll (rank (p.S s) V (p.key s)) := by
      unfold Ears; rw [← hs]; exact ⟨_, hz.tasked⟩
   exact ht

def collect (f:Cog)(k:Knob) (r:ℕ): Meld :=
    let o:=r+p.e
    let M:=p.e+6
    let even1 (x:Word)(a:Bid.arm):Coin:= Coin.mult (Coin.mult a.2.1 (scaleC k r x a.1))
                                                            (Coin.inv (scaleC k o x a.1))
    have he:Kn even1 := Coin.multK
       (Coin.multK Kn.next.left ((scaleK k r).comp Kn.first))
       (Coin.invK ((scaleK k o).comp Kn.first))
    { P:={ n:= fun b=> if b then p.n else ⟨_,Kn.fix 0⟩, route:=fun _=>p.route,
           margin:=⟨fun x a=>M*k.height.f x a,(Kn.fix _).times k.height.runs⟩,scans:=fun _=>f }
      f:=⟨_,he⟩ }
abbrev reserve : ℕ := p.e+6
abbrev foldC(p:Branch)(c:ℕ):= c+p.e+106
lemma poem {s:Port}{V H c i f k}
   (h:p.Trust s i V c (H+p.reserve*s.d) f)(hc:1 ≤ c)(ho:Align s k) :
   Ears s (powder (Oven.price (p.foldC c))) H (i+p.e) ((p.collect f k i).cooked) (∑ j∈p.S s, V j):=by
   classical
   let u:=p.collect f k i
   let C:=p.foldC c
   let o:=i+p.e
   let D:=massB i s.d
   let B:=massB o s.d
   have hA:0<D:=mass0 i s.d
   have hB:0<B:=mass0 o s.d
   let W:Rill.EV:= fun b j=> V j/D
   have hk:C≥p.reserve∧C≥100∧ c ≤  C:=by unfold C reserve foldC; omega
   have hN(q:Bool) : u.P.labels s q  ≤  p.n.f s.l.x s.info := by cases q <;> simp [Oven.labels,u,collect]
   have hs(b:Bool)(j):∃ w,(j<u.P.labels s b) → (u.P.rel s b j).Feeds (u.P.scans b) c (H+p.reserve*s.d) w (W b j):=by
      by_cases ht:j<u.P.labels s b
      · obtain ⟨w,h0⟩:=h.tick j (mem_range.2 (ht.trans_le (hN b)))
        exact ⟨w,fun _=>h0⟩
      exact ⟨fun _=>0,fun hz=> (ht hz).elim⟩
   choose w hw using hs
   have he0:u.P.margin.f s.l.x s.info=p.reserve*s.d:= by
         simp [u,collect,reserve,ho.2.1]
   have he:u.P.Thaw s C H w W:=by
      refine ⟨hk.2.1,ho.1,by rw [he0]; exact Nat.mul_le_mul_right _ hk.1,?_,?_⟩
      · intro b; apply lt_of_le_of_lt (hN b)
        apply h.cheaply.trans_le
        exact Nat.pow_le_pow_right Nat.zero_lt_two (Nat.mul_le_mul_right _ (by unfold C foldC; omega))
      intro b i h; unfold Oven.ext; rw [he0]; exact fewer (hw b i h) hc hk.2.2 le_rfl
   let m:=p.n.f s.l.x s.info
   let v:=∑ j∈p.S s, V j
   have hi(Den):0 < massB Den s.d:= mass0 ..
   have hb:B=D*massB p.e s.d:= mass_mul ..
   have hr:m < massB p.e s.d:= by unfold massB; exact_mod_cast h.cheaply
   have hl : u.Lip s 1 (v/B) W:=by
     refine ⟨?_,le_rfl,?_,fun x y hx hy=>?_⟩
     · rw [abs_div,abs_of_pos hB,div_le_one hB]
       apply le_trans (abs_sum_le_sum_abs .. )
       have hz:∑ j∈p.S s, |V j| ≤  ∑ _∈p.S s,D:=by
            exact sum_le_sum fun j hz=>amplitude (p:=p.port s j) (h.tick j hz)
       apply hz.trans; simp [S,m] at *
       rw [hb]; nlinarith
     · rw [he0]; simp [u,collect,Oven.labels,m] at *
       unfold reserve; rw [add_mul,pow_add]; unfold massB at hr
       have hv: (16:ℝ)  ≤  (2:ℝ)^(6*s.d):=calc
          _  ≤  (2:ℝ)^(6:ℕ):=by norm_num
          _  ≤  _:=pow_le_pow_right₀ (by norm_num) (by have := ho.1.1; omega)
       have hp := mass1 p.e s.d; unfold massB at hp
       nlinarith
     have hx0:u.tally s W true=v/D:=by
       simp only [v,D,W,u,collect,Meld.tally,S,Oven.labels,ite_true,sum_div]
     rw [hx0]
     simp only [u,collect,Coin.mul0,Coin.inv0,scalen ho,← div_eq_mul_inv,one_mul]
     change |x.v*D/B - v/B|  ≤  |x.v-v/D| +_
     apply le_trans _ (le_add_of_nonneg_right (abs_nonneg _))
     have hx1:x.v*D/B-v/B=(x.v-v/D)* (D/B):= by field_simp
     rw [hx1,abs_mul,abs_of_nonneg (by positivity : 0 ≤  D/B)]
     apply mul_le_of_le_one_right (abs_nonneg _)
     apply (div_le_one hB).2
     have hz0:=mass1 p.e s.d; nlinarith
   exact ⟨_,u.stream s he hl⟩
end Branch
end ExactDerandomization.Fret

end

section

namespace ExactDerandomization.Fret
open Relay Counter Rill Analysis Finset

inductive Lyric where
   | solo (i:ℕ) (f:Cub CoinQuery Coin)
   | use (i:ℕ) (p:Cog)
   | duet (p:Doop)(x y:Lyric)(o:ℕ)
   | heap (sum0:Bool)(p:Branch)(f: Lyric)

namespace Lyric
def weight: Lyric  → ℕ
   | .solo i _| .use i _=>i
   | .duet _ _ _ o=> o
   | .heap b p f=> if b then weight f+p.e else weight f

def pulse (i j:ℕ):= Doop.fast i j+i+j+6
def tail : Lyric → ℕ
   | .solo ..| .use ..=>0
   | .duet _ x y _=> pulse (weight x) (weight y)+max (tail x) (tail y)
   | .heap b p f=> (if b then p.reserve else 0)+tail f

def operate (e i j c:ℕ):= powder (Oven.price (Bid.joinCost e i j c))
def cost (p: Lyric)(c:ℕ): ℕ := match p with
   | .solo ..=> powder 100
   | .use ..=>c
   | .duet _ x y _=> operate (Doop.fast (weight x) (weight y)) (weight x) (weight y)
                                      (max (cost x c) (cost y c))
   | .heap b p f=> if b then powder (Oven.price (p.foldC (cost f c))) else
                                      powder (Survey.priceB (cost f c+p.e+100))

lemma cost_hi {p:Lyric}{c:ℕ}(hc:1 ≤ c):1 ≤ p.cost c:= by
   have hp (i:ℕ): 1 ≤ powder i:=by unfold powder; omega
   cases p with
   | solo=> exact hp _
   | use=> exact hc
   | duet=> exact hp _
   | heap b=> cases b <;> exact hp _

noncomputable def choir (s:Knob) (p:Lyric):Cog:= match p with
   | .solo i f=> Brick.solo s f i
   | .use _ f=>f
   | .duet p x y o=>
      let i:=weight x
      let j:=weight y
      (p.ration.uPair s i j o (Doop.fast i j) (choir s x) (choir s y)).cooked
   | .heap b p f=>
        let q:=choir s f
        if b then (p.collect q s (weight f)).cooked else (p.bowl q).poll

inductive Lethe (p:Knob)(c T:ℕ) : Port →  Lyric  → ℝ → Prop where
   | byear {s r f V} :
       Ears s c T r f V  →  Lethe p c T s (.use r f) V
   | played {s i f}(h:Align s p)(e:Live s p T)
       (hb: |(f.f s.l.x (s.info,s.src)).v|  ≤  massB i s.d):
          Lethe p c T s (.solo i f) (f.f s.l.x (s.info,s.src)).v
   | doo {s i j A B u o} (h:Align s p)
       (ha:Lethe p c T s i A) (hb:Lethe p c T s j B) (hr:|u.val A B| ≤ massB o s.d):
              Lethe p c T s (.duet u i j o) (u.val A B)
   | little {s q f V b} (h:Align s p)
       (he:q.n.f s.l.x s.info<(2:ℕ)^(q.e*s.d)) (hg:∀ i∈q.S s,Lethe p c T (q.port s i) f (V i)):
               Lethe p c T s (.heap b q f) (if b then ∑ i∈q.S s,V i else rank (q.S s) V (q.key s))

theorem song {p c T s f V} (hc:1 ≤ c) (h:Lethe p c T s f V){H:ℕ}(he:H+f.tail*s.d ≤ T):
     Ears s (f.cost c) H f.weight (choir p f) V:= by
    induction h generalizing H with
    | @byear s i q v h=> apply supply h hc le_rfl; exact (Nat.le_add_right ..).trans he
    | @played s i f h hl hb=>
      have hp:H ≤ T :=(Nat.le_add_right ..).trans he
      exact ⟨_, Brick.each0 p f i s H h ((Nat.pow_le_pow_right Nat.zero_lt_two hp).trans hl) rfl hb⟩
    | @doo s i j A B u o h h1 h2 h3 ia ib=>
      let z:=pulse i.weight j.weight
      let v:= H+z*s.d
      let k:=max (i.cost c) (j.cost c)
      have hp:v+max (tail i) (tail j)*s.d ≤ T:=by
          change H+(z+max i.tail j.tail)*s.d ≤ T at he
          unfold v; rwa [add_mul,← add_assoc] at he
      have hi : v+(tail i)*s.d ≤ T := by
         apply le_trans _ hp
         gcongr; exact le_max_left ..
      have hj : v+(tail j)*s.d ≤ T:=by
         apply le_trans _ hp
         gcongr; exact le_max_right ..
      apply Bid.joint u.ration h (u.legit ..) ((cost_hi (p:=i) hc).trans (le_max_left ..)) _ _ h3
      · exact supply (ia hi) (cost_hi hc) (le_max_left ..) le_rfl
      exact supply (ib hj) (cost_hi hc) (le_max_right ..) le_rfl
    | @little s q f V b h hz hf ih=>
      let i:= f.weight
      let w:=choir p f
      have hp:q.Trust s i V (f.cost c) (H+(if b then q.reserve else 0)*s.d) w:= by
         refine ⟨hz,fun j hj=>ih j hj ?_⟩
         unfold tail at he; dsimp only [Branch.port]; rwa [add_mul,← add_assoc] at he
      cases b
      · simp only [choir,cost,weight,Bool.false_eq_true,ite_false]
        simp only [Bool.false_eq_true,ite_false,zero_mul,add_zero] at hp
        exact q.lease hp (cost_hi hc) h.1
      simp only [choir,cost,weight,ite_true]
      exact q.poem hp (cost_hi hc) h

lemma Lethe.bnd {p c T s f V}(h:Lethe p c T s f V):
    |V|  ≤  massB f.weight s.d:= by
   induction h with
   | byear he=> exact amplitude he
   | played _ _ hb=> exact hb
   | doo _ _ _ he _ _=> exact he
   | @little s q f V b h he hg ih=>
     let X:=massB f.weight s.d
     have hp:0 ≤ X:= (mass0 ..).le
     have hi (i:ℕ)(e:i∈q.S s):|V i| ≤ X:=ih i e
     cases b
     · rw [ite_eq_right (by simp),abs_of_nonneg (rank_nn ..)]; exact rank_le hp
                              (fun i e=>le_trans (le_abs_self _) (hi _ e))
     · simp only [weight,ite_true]
       refine le_trans (abs_sum_le_sum_abs ..) ?_
       apply le_trans (b:=∑ i ∈ q.S s,X) (sum_le_sum hi)
       simp only [Branch.S, sum_const,card_range,nsmul_eq_mul]
       have hr:(q.n.f s.l.x s.info:ℝ)< massB q.e s.d:=by unfold massB; exact_mod_cast he
       rw [mass_mul]
       unfold X at *; nlinarith

abbrev bi (p:Doop)(x y:Lyric):Lyric:= .duet p x y (Doop.fast x.weight y.weight)
lemma Lethe.bundle {p c T s i j A B} (h:Lethe p c T s i A) (e:Lethe p c T s j B)
    (hs:Align s p)(op:Doop):
    Lethe p c T s (bi op i j) (op.val A B):=
   .doo hs h e (op.geom _ _ s.d hs.1.1 h.bnd e.bnd)

end Lyric
end ExactDerandomization.Fret

end

section

namespace ExactDerandomization.Fret
open Relay Counter Rill Analysis Finset
namespace Bid
variable(p:Bid)
lemma fixedjoint {s:Port}{k i j o e c H f g V X w b} (h: Align s k) (he:p.Fit e i j) (hc:1 ≤  c)
   (h1:s.Feeds f c (H+(e+i+j+6)*s.d) w (V/massB i s.d))(h2:s.Feeds g c (H+(e+i+j+6)*s.d) b (X/massB j s.d))
   (hv:|p.truef V X| ≤ massB o s.d) :
   let q:=p.uPair k i j o e f g
   s.Feeds q.cooked (powder (Oven.price (joinCost e i j c))) H (q.out s (fun t _=> if t then w else b)) (p.truef V X /massB o s.d):= by
   have ha:=amplitude (p:=s) (v:=V) (f:=f) (i:=i) (T:=H+(e+i+j+6)*s.d) (c:=c) ⟨w,h1⟩; have hb:=amplitude (p:=s) (v:=X) (f:=g) (i:=j) (T:=H+(e+i+j+6)*s.d) (c:=c) ⟨b,h2⟩
   let d:=s.d; have hd:1 ≤ s.d:=h.1.1
   let q:=p.uPair k i j o e f g
   let f0:Rill.EV:=fun t _=> if t then V/massB i d else X/massB j d
   let g0:Rill.DW:=fun t _=> if t then w else b
   let C:=joinCost e i j c
   have hC:C≥100∧ c ≤ C:=by unfold C joinCost; omega
   have hM : q.P.margin.f s.l.x s.info=(e+i+j+6)*s.d:=by simp [q,uPair,h.2.1]
   have he0:q.P.Thaw s C H g0 f0:=by
      refine ⟨hC.1,h.1,?_,?_,?_⟩
      · rw [hM]; unfold C joinCost; exact Nat.mul_le_mul_right s.d (by omega)
      · intro b; change 1<2^(C*s.d); have hz:=growing (C*s.d); nlinarith
      intro b i hi; cases b
      · have hu: q.P.scans false=g:=by simp [q,uPair]
        rw [hu, Oven.ext,hM]; exact fewer h2 hc hC.2 le_rfl
      · have hu:q.P.scans true=f:=by simp [q,uPair]
        rw [hu,Oven.ext,hM]; exact fewer h1 hc hC.2 le_rfl
   have hl : q.Lip s (massB (e+i+j) s.d) (p.truef V X/massB o s.d) f0:=by
      refine ⟨by rw [abs_div,abs_of_pos (mass0 ..)]; exact (div_le_one (mass0 ..)).2 hv,
           mass1 ..,?_,fun x y hs hz=>?_⟩
      · rw [hM]; let n:=e+i+j
        change massB n s.d*4*3 ≤ massB (n+6) s.d
        rw [mass_mul n 6]; have hh : 12  ≤ massB 6 s.d:=by
           unfold massB
           calc
              (12:ℝ)  ≤  2^(6:ℕ):=by norm_num
              _ ≤ _:=pow_le_pow_right₀ (by norm_num) (by omega)
        have hp:=mass0 n s.d; rw [mul_assoc]; exact mul_le_mul_of_nonneg_left (by linarith) hp.le
      · have hx:q.tally s f0 true=V/massB i s.d:=by simp [q,Meld.tally,Oven.labels,uPair,f0,d]
        have ht:q.tally s f0 false=X/massB j s.d:=by simp [q,Meld.tally,Oven.labels,uPair,f0,d]
        rw [hx] at hs; rw [ht] at hz; rw [hx,ht]
        simp only [q,uPair,remote,Coin.mul0,Coin.inv0,he.goodC,scalen h,← div_eq_mul_inv]
        exact behold _ hd _ _ _ _ he ha hb hs hz
   exact q.stream s he0 hl
end Bid
namespace Branch
variable (p:Branch)
structure Faith (s:Port)(i:ℕ)(V:ℕ→ℝ)(c H:ℕ)(f:Cog)(w:ℕ→Tape):Prop where
    cheaply : p.n.f s.l.x s.info < (2:ℕ)^(p.e*s.d)
    tick :∀ j∈p.S s,(p.port s j).Feeds f c H (w j) (V j/massB i s.d)

lemma leased {s:Port}{V H c i f w}(h:p.Faith s i V c H f w)(hc:1 ≤ c)(ho:s.OK):
    s.Feeds (p.bowl f).poll (powder (Survey.priceB (c+p.e+100))) H
       (fun t=> (rankN (p.S s) (fun j=>(w j t).toNat) (p.key s):ℤ)) ((rank (p.S s) V (p.key s))/massB i s.d):=by
   classical
   let u:=p.bowl f
   let W:= fun (j:ℕ)=> V j/massB i s.d
   have hz : u.Clue s (c+p.e+100) H W w:= by
      refine ⟨by omega,ho,?_ ,fun j hj=>fewer (h.tick j (mem_range.2 hj)) hc (by omega) le_rfl⟩
      apply h.cheaply.trans_le (Nat.pow_le_pow_right Nat.zero_lt_two ?_)
      gcongr; omega
   let v:=massB i s.d
   have hs:rank (p.S s) W (p.key s)=rank (p.S s) V (p.key s)/v:=by
      have hm:W=(fun j=>v⁻¹*V j):=funext fun _=> by unfold v W; ring
      rw [hm,scaled_rank (by unfold v; positivity)]; ring
   rw [← hs]; exact hz.tasked
lemma poems {s:Port}{V H c i f k tapes}
   (h:p.Faith s i V c (H+p.reserve*s.d) f tapes)(hc:1 ≤ c)(ho:Align s k) :
   let u:=p.collect f k i
   s.Feeds u.cooked (powder (Oven.price (p.foldC c))) H (u.out s (fun _ j=>tapes j)) ((∑ j∈p.S s, V j)/massB (i+p.e) s.d):=by
   classical
   let u:=p.collect f k i
   let C:=p.foldC c
   let o:=i+p.e
   let D:=massB i s.d
   let B:=massB o s.d
   have hA:0<D:=mass0 i s.d
   have hB:0<B:=mass0 o s.d
   let W:Rill.EV:= fun b j=> V j/D
   have hk:C≥p.reserve∧C≥100∧ c ≤  C:=by unfold C reserve foldC; omega
   have hN(q:Bool) : u.P.labels s q  ≤  p.n.f s.l.x s.info := by cases q <;> simp [Oven.labels,u,collect]
   let w:DW:=fun _ j=>tapes j
   have hw(b:Bool)(j) (ht:j<u.P.labels s b): (u.P.rel s b j).Feeds (u.P.scans b) c (H+p.reserve*s.d) (w b j) (W b j):=
            h.tick j (mem_range.2 (ht.trans_le (hN b)))
   have he0:u.P.margin.f s.l.x s.info=p.reserve*s.d:= by
         simp [u,collect,reserve,ho.2.1]
   have he:u.P.Thaw s C H w W:=by
      refine ⟨hk.2.1,ho.1,by rw [he0]; exact Nat.mul_le_mul_right _ hk.1,?_,?_⟩
      · intro b; apply lt_of_le_of_lt (hN b)
        apply h.cheaply.trans_le
        exact Nat.pow_le_pow_right Nat.zero_lt_two (Nat.mul_le_mul_right _ (by unfold C foldC; omega))
      intro b i h; unfold Oven.ext; rw [he0]; exact fewer (hw b i h) hc hk.2.2 le_rfl
   let m:=p.n.f s.l.x s.info
   let v:=∑ j∈p.S s, V j
   have hi(Den):0 < massB Den s.d:= mass0 ..
   have hb:B=D*massB p.e s.d:= mass_mul ..
   have hr:m < massB p.e s.d:= by unfold massB; exact_mod_cast h.cheaply
   have hl : u.Lip s 1 (v/B) W:=by
     refine ⟨?_,le_rfl,?_,fun x y hx hy=>?_⟩
     · rw [abs_div,abs_of_pos hB,div_le_one hB]
       apply le_trans (abs_sum_le_sum_abs .. )
       have hz:∑ j∈p.S s, |V j| ≤  ∑ _∈p.S s,D:=by
            exact sum_le_sum fun j hz=>amplitude (p:=p.port s j) (i:=i) (f:=f) (c:=c)
                         (T:=H+p.reserve*s.d) ⟨tapes j,h.tick j hz⟩
       apply hz.trans; simp [S,m] at *
       rw [hb]; nlinarith
     · rw [he0]; simp [u,collect,Oven.labels,m] at *
       unfold reserve; rw [add_mul,pow_add]; unfold massB at hr
       have hv: (16:ℝ)  ≤  (2:ℝ)^(6*s.d):=calc
          _  ≤  (2:ℝ)^(6:ℕ):=by norm_num
          _  ≤  _:=pow_le_pow_right₀ (by norm_num) (by have := ho.1.1; omega)
       have hp := mass1 p.e s.d; unfold massB at hp
       nlinarith
     have hx0:u.tally s W true=v/D:=by
       simp only [v,D,W,u,collect,Meld.tally,S,Oven.labels,ite_true,sum_div]
     rw [hx0]
     simp only [u,collect,Coin.mul0,Coin.inv0,scalen ho,← div_eq_mul_inv,one_mul]
     change |x.v*D/B - v/B|  ≤  |x.v-v/D| +_
     apply le_trans _ (le_add_of_nonneg_right (abs_nonneg _))
     have hx1:x.v*D/B-v/B=(x.v-v/D)* (D/B):= by field_simp
     rw [hx1,abs_mul,abs_of_nonneg (by positivity : 0 ≤  D/B)]
     apply mul_le_of_le_one_right (abs_nonneg _)
     apply (div_le_one hB).2
     have hz0:=mass1 p.e s.d; nlinarith
   exact u.stream s he hl
end Branch
end ExactDerandomization.Fret

end

section

namespace ExactDerandomization.Relay
open Counter
namespace Cog
variable (q:Cub ℕ ℕ)

abbrev repx {α} (q:Cub ℕ ℕ)(x:Word)(a:ℕ×α) := (q.f x a.1,a.2)
lemma repK {α} [Wire α] : Kn (repx (α:=α) q):= (q.runs.comp Kn.first).tuple Kn.next

def stampT (q:Cub ℕ ℕ) {α β:Type}[Wire α][Wire β](v:Cub (ℕ×α) β) :Cub (ℕ×α) β:=
   ⟨fun x a=>v.f x (repx q x a),v.runs.comp (repK ..)⟩
def outerQ (q:Cub ℕ ℕ)(v:Cub Drain Site): Cub Drain Site:=
   ⟨fun x a=>v.f x ((q.f x a.1.1,a.1.2),a.2),
           v.runs.comp (((q.runs.comp Kn.first.left).tuple Kn.first.right).tuple Kn.next)⟩
def ren : Cog→ Cog
    | edit f=> edit (stampT q f)
    | toss p e=> toss (stampT q p) (outerQ q e)
    | seq a b=> seq (ren a) (ren b)
    | Cog.bif p a b=> Cog.bif (stampT q p) (ren a) (ren b)
    | loop p a=> loop (stampT q p) (ren a)
lemma renameR {l c b d n p a u} (h:Lot.Mane l c b d n p a u){x:ℕ} (e:q.f l.x x=n):
   Lot.Mane l c b d x (ren q p) a u:= by
    induction h
    · rename_i he hf hg
      apply Lot.Mane.edit _ hf hg
      simp only [stampT,repx,e]; exact he
    · rename_i eh ek hl hi hm hp
      refine .toss ?_ ?_ hl hi hm hp
      · simp only [stampT,repx,e]; exact eh
      simp only [outerQ,e]; exact ek
    · exact .seq (by assumption) (by assumption)
    · apply Lot.Mane.yes _ (by assumption)
      simp only [stampT,repx,e]; assumption
    · apply Lot.Mane.no _ (by assumption)
      simp only [stampT,repx,e]; assumption
    · apply Lot.Mane.more _ (by assumption) (by assumption)
      simp only [stampT,repx,e]; assumption
    · apply Lot.Mane.stop _ (by assumption)
      simp only [stampT,repx,e]; assumption

end Cog
namespace Lot
lemma Mane.rise {l c q w t p d a b}(h:Mane l c ⟨w,t⟩ d q p a b){H}(he:t≤H):
    Mane l c ⟨w,H⟩ d q p a b:=by
   have h1(i j k:ℕ):span c k t i j → span c k H i j:= fun e=>
      le_trans e (Nat.add_le_add_right (Nat.mul_le_mul_left c he) _)
   have hh(a)(e:l.state c ⟨w,t⟩ a):l.state c ⟨w,H⟩ a:=⟨e.1,h1 _ _ _ e.2⟩
   have hg(a q:ℕ)(e:l.jump c ⟨w,t⟩ d a q):l.jump c ⟨w,H⟩ d a q:=⟨e.1,h1 _ _ _ e.2⟩
   induction h
   · exact .edit (by assumption) (hh _ ‹_›) (hh _ ‹_›)
   · rename_i he hf hk hl he0 ho
     exact .toss he hf (hh _ hk) (hh _ hl) (hg _ _ he0) ho
   · 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) (hh _ ‹_›)

lemma absorb {c t d W :ℕ} (h:1≤c)(hp:t≤c*d)(_:1≤W)(hz:d≤W)
     {j k}(h1:span c W t j k):
    span (4*c) W 0 j k:= by
   have hs : t ≤ c*W:= le_trans hp (Nat.mul_le_mul_left c hz)
   have hl:=lax h1 (m:=1) (D:=4*c) (by omega) h; unfold span
   nlinarith [Nat.mul_le_mul_left c hs]
lemma Mane.pause {l c q w t p d a b}(h:Mane l c ⟨w,t⟩ d q p a b)
   (he:1≤ c)(ho:1≤d)(hr:d≤w)(hp:t≤c*d):
   Mane l (4*c) ⟨w,0⟩ d q p a b:=by
   have hh(v)(h:l.state c ⟨w,t⟩ v):l.state (4*c) ⟨w,0⟩ v:=
      ⟨h.1,absorb he hp (ho.trans hr) hr h.2⟩
   have hg(v t1)(h:l.jump c ⟨w,t⟩ d v t1):l.jump (4*c) ⟨w,0⟩ d v t1:= by
       have he0 : d≤w-(l.book t1).w:=by have hu:(l.book t1).w+d≤w:=h.1; omega
       exact ⟨h.1,absorb he hp (ho.trans he0) he0 h.2⟩
   induction h
   · exact .edit (by assumption) (hh _ ‹_›) (hh _ ‹_›)
   · rename_i he hf hk hl he0 ho
     exact .toss he hf (hh _ hk) (hh _ hl) (hg _ _ he0) ho
   · 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) (hh _ ‹_›)
end Lot
end ExactDerandomization.Relay

end

section

/-! Scratch-control algebra. -/
namespace ExactDerandomization.Fret
open Relay Counter Rill

abbrev Punct (p:Port)(c v:ℕ) := lb v +1 ≤ c*p.d
lemma holdroom {p:Port}{c u v:ℕ}(_:p.OK)(h:Punct p c u)(e:Punct p c v):
    Punct p (4*c) (enc (u,v)):=by
   have hc:0<c:=by by_contra! hx; unfold Punct at *; simp_all
   unfold Punct at *
   have he : lb (enc (u,v))≤ 2*lb u+lb v+2:=measure_pair _ _
   nlinarith
lemma punctspan {p:Port}{c v t}(hc:Punct p c v) (ht:1≤c) :
   span c p.d t t (lb v+1):=by
   unfold Punct span at *
   nlinarith [Nat.mul_le_mul_right p.d (show c≤c*c by nlinarith)]
lemma plight {p:Port}{c v t}(hc:Punct p c v) (hp:p.OK)(ht:1≤c):
    p.l.state c ⟨p.w,t⟩ (p.s v):= by
   refine ⟨hp.2.2,movespan ?_ hp.2.1⟩
   have h:=punctspan hc ht (t:=t); unfold span at *; dsimp; omega
lemma punct0 {p:Port}(h:p.OK) {c}(ht:2≤c): Punct p c 0:= by
   unfold Punct; rw [lb_zero]; have he:=h.1; nlinarith
lemma punct_up {p:Port} {c v j}(h:Punct p c v)(ht:c≤j):Punct p j v:=
   h.trans (Nat.mul_le_mul_right p.d ht)

/- holding structural query control and visiting neighboring digit routine.
For same absolute numerical place (special case = zero). -/
namespace Cargo
def mint (P:Cub History ℕ)
    (x:Word)(q:Slip):ℕ:=
   let a:History:= dec q.1
   postcard (P.f x (a.1,q.2)) a.2
lemma mintK(P):Kn (mint P):= by
   have h:= (Kn.unpack (α:=History)).comp (Kn.first (β:=ℕ))
   exact Kn.wash.comp ((P.runs.comp (h.left.tuple Kn.next)).tuple h.right)
def openx (_:Word)(a:Lore ℕ):History:=(a.2,0)
lemma openK:Kn openx:=Kn.next.tuple (Kn.fix _)
def encase (P:Cub History ℕ) (q:Cog):Cog:=
   .seq (etch _ openK) (Cog.focus ⟨_,mintK P⟩ q)

def transit (f:Cub History ℕ)(p:Port)(i:ℕ) : Port:={p with info:=f.f p.l.x (p.info,i)}
lemma aboard {p:Port} {c v t q} {f:Cub History ℕ}
   (hp:p.OK)(ht:1≤c)(hz:Punct p c v)
   {u:Site}(he:(transit f p v).comp t c q (p.s 0) u):
   p.comp t (4*c) (encase f q) (p.s v) (hold v u):= by
    have h1:=punctspan hz ht (t:=t)
    have hc : p.comp t (4*c) (Cog.focus ⟨_,mintK f⟩ q)
       (hold v (p.s 0)) (hold v u) := by
      refine Cog.focus_word _ he ?_ h1 hp.2.1 (by omega) ht ht
      simp [mint,transit,postcard]
    exact .seq (etches _ _ (i:=v) rfl (plight (punct_up hz (by omega)) hp (by omega)) hc.spots.1) hc

def switch (k:Cub ℕ ℕ)(x:Word)(v:ℕ):ℕ:=
   let a:History:=dec v
   postcard (k.f x a.1) a.2
lemma switchK(k):Kn (switch k):=by
   have h:= (Kn.unpack (α:=History))
   exact Kn.wash.comp ((k.runs.comp h.left).tuple h.right)

def strip (_:Word)(n:ℕ):ℕ:= postcard (dec n:History).1 0
lemma stripK : Kn strip :=Kn.wash.comp ((Kn.unpack (α:=History)).left.tuple (Kn.fix _))

abbrev only0 (p:Port)(c:ℕ):=p.comp 0 c
def flag0:Flag := ⟨fun _ a=>decide (a.2.1=0),Kn.next.left.eq (Kn.fix 0)⟩
def knock : Cog:= etch (α:=ℕ) (fun _ _=>(0:ℕ)) (Kn.fix _)

def choose (hint A B:Cog) := Cog.seq (Cog.ren ⟨_,stripK⟩ hint) (.bif flag0
                                (.seq knock A) (.seq knock B))

lemma expands {p:Port}{c q t x y}(h: p.comp 0 c q x y):
   p.comp t c (Cog.ren ⟨_,stripK⟩ q) x y :=
    (Cog.renameR ⟨_,stripK⟩ h (by simp [strip,postcard])).rise (Nat.zero_le _)

lemma flavor {p:Port}{c b q g f i t v} (_:p.OK) (h:only0 p c q (p.s 0) (p.s b))
    (ha:b=0 → Ears p c t i g v)(hb:b≠0 → Ears p c t i f v):
        Ears p c t i (choose q g f) v:=by
    by_cases hh:b=0
    · obtain ⟨w,hr,hw⟩:=ha hh
      refine ⟨w,hr,⟨fun k hk=>?_⟩⟩
      have ht:=hw.digits _ hk; have hg:=expands h (t:=k)
      refine .seq hg (.yes (show decide (b=0)=true by simp [hh]) (.seq ?_ ht))
      exact etches _ _ (i:=b) rfl hg.spots.2 ht.spots.1
    obtain ⟨w,hr,hw⟩:=hb hh
    refine ⟨w,hr,⟨fun k hk=>?_⟩⟩
    have ht:=hw.digits _ hk; have hg:=expands h (t:=k)
    refine .seq hg (.no (show decide (b=0)=false by simp [hh]) (.seq ?_ ht))
    exact etches _ _ (i:=b) rfl hg.spots.2 ht.spots.1

def combine (hint B:Cog)(C:Cub History ℕ):Cog:=
   .seq (Cog.ren ⟨_,stripK⟩ hint)
        (.seq (encase C B)
           (etch (α:=History) (fun _ h=>h.2.2) Kn.next.right))

lemma restores {p:Port}{c b q g C i t v}
    (hp:p.OK) (hb:Punct p c b)(hc:1≤ c)(h:only0 p c q (p.s 0) (p.s b))
    (ha:Ears (transit C p b) c t i g v) :
        Ears p (4*c) t i (combine q g C) v:=by
   obtain ⟨w,ht,h0⟩:=ha
   refine ⟨w,ht,⟨fun k hk=>?_⟩⟩
   have hz:=h0.digits k hk
   have he:=aboard hp hc hb hz
   have hu := (expands (t:=k) h).mono (D:=4*c) (by omega) hc
   refine .seq hu (.seq he ?_)
   exact etches _ _ (i:=((b,enc (dsign w k)):History)) rfl he.spots.2
                         (hz.mono (c:=c) (D:=4*c) (by omega) hc).spots.2
end Cargo
end ExactDerandomization.Fret

end

section

namespace ExactDerandomization.Fret
open Relay Counter Rill

/-- transparent query/list iteration -/
structure Camp where
   n : Cub ℕ ℕ
   recipe : Cub History ℕ
   prog : Cog
   post : Cub (Lore (ℕ×ℕ)) ℕ

namespace Camp
variable (r:Camp)
abbrev Info:=Lore (ℕ×ℕ)
def cond0 (x:Word)(a:Info): Bool:= decide (a.2.1 < r.n.f x (dec a.1:History).1)
lemma condK:Kn r.cond0:=Kn.next.left.lt (r.n.runs.comp ((Kn.unpack (α:=History)).comp Kn.first).left)

def work0 (x:Word)(a:Info):ℕ×ℕ:= ((dec a.2.1:ℕ×ℕ).1+1,r.post.f x ((dec a.1:History).1,a.2))
lemma workK:Kn r.work0:= ((Kn.unpack (α:=History)).comp Kn.next.left).left.succ.tuple
                 (r.post.runs.comp (((Kn.unpack (α:=History)).comp Kn.first).left.tuple Kn.next))

def solve :Cog:= .loop (gear _ r.condK) (.seq (Cargo.encase r.recipe r.prog) (etch _ r.workK))
def walk0 :Cog:= .seq (etch (α:=ℕ) (fun _ a=> ((0,a.2):ℕ×ℕ)) ((Kn.fix _).tuple Kn.next))
                         (.seq r.solve (etch (α:=ℕ×ℕ) (fun _ a=>a.2.2) Kn.next.right))

variable (p:Port)(t:ℕ)
def n0 := r.n.f p.l.x p.info
def poster (a b c:ℕ) := r.post.f p.l.x (p.info,enc ((a,b):ℕ×ℕ),c)

lemma round {p:Port}{t c u:ℕ} (h:p.OK)(ht:2≤ c)(v x:ℕ→ℕ)(he:v 0=u) (hn:Punct p c (r.n0 p))
   (hs:∀ i≤r.n0 p,Punct p c (v i))
   (hh:∀ i<r.n0 p,r.poster p i (v i) (x i)=v (i+1) ∧
              (Cargo.transit r.recipe p (enc (i,v i))).comp t c r.prog (p.s 0) (p.s (x i))):
    p.comp t (16*c) r.walk0 (p.s u) (p.s (v (r.n0 p))) := by
   let pay:=16*c
   have hc:1≤c:=by omega
   have hu :c≤pay:=by unfold pay; omega
   let z:=r.n0 p
   have hz(i:ℕ)(hi:i≤z):Punct p (4*c) (enc (i,v i)):=holdroom h
                       (by unfold Punct; exact le_trans (Nat.add_le_add_right (lb_mono hi) _) hn) (hs i hi)
   have hx(i:ℕ)(hi:i≤z):p.l.state pay ⟨p.w,t⟩ (p.s (enc (i,v i))):=
                            plight (punct_up (hz i hi) (by unfold pay; omega)) h (by omega)
   have hk (i:ℕ)(hi:i≤z):p.comp t pay r.solve (p.s (enc (i,v i))) (p.s (enc (z,v z))) := by
     have hd(i:ℕ) : (gear _ r.condK).f p.l.x (postcard p.info t,
                                           Pause (i,v i) p.src)=decide (i<z):=by
        rw [gear_at]; simp [postcard,z,cond0,n0]
     induction hi using Nat.decreasingInduction with
     | self=> exact .stop (by exact (hd _).trans (by simp)) (hx z le_rfl)
     | of_succ i hi ih=>
       obtain ⟨hj,hp⟩:=hh i hi
       have hA:=Cargo.aboard h (by omega:1 ≤4*c) (hz i hi.le)
                                               (hp.mono (D:=4*c) (by omega) hc)
       rw [show 4*(4*c)=pay by unfold pay; omega] at hA
       apply Lot.Mane.more ((hd _).trans (by simp [hi]))
                 (Lot.Mane.seq hA ?_) ih
       exact etches _ _ (i:=((enc (i,v i),x i):ℕ×ℕ)) (by simp [work0,postcard]; exact hj)
                       hA.spots.2 (hx _ hi)
   have h0: v 0=u:=he
   have hf:=hk 0 (Nat.zero_le _)
   subst u
   refine .seq (etches _ _ (i:=v 0) rfl ?_ hf.spots.1)
                 (.seq hf (etches _ _ (i:=(z,v z)) rfl hf.spots.2 ?_))
   · exact plight (punct_up (hs 0 (Nat.zero_le _)) hu) h (by omega)
   exact plight (punct_up (hs z le_rfl) hu) h (by omega)
end Camp
end ExactDerandomization.Fret

end

section

namespace ExactDerandomization.Fret
open Relay Counter Rill Finset
/-- Probe an actual finite-margin numerical question. -/
structure Badge where
   p : Cog
   k:Knob
   i:ℕ
   m:ℕ
   test:Cub (ℕ×Coin) ℕ

namespace Badge
variable (p:Badge)
def one : Oven:=
   ⟨fun b=>if b then ⟨_,Kn.fix 1⟩ else ⟨_,Kn.fix 0⟩,fun _=>⟨_,Kn.first⟩,⟨_,Kn.fix 0⟩,fun _=>p.p⟩

def dispatch (x:Word)(q:ℕ):ℕ:=
   let v:History:=dec q
   postcard v.1 (p.m*p.k.height.f x v.1)
lemma dispatchK: Kn p.dispatch:=by
    have hp:= (Kn.unpack (α:=History)).left
    exact Kn.wash.comp (hp.tuple ((Kn.fix _).times (p.k.height.runs.comp hp)))

abbrev cell (p:Badge)(x:Word)(q:ℕ)(v:Comb):Coin :=
    Coin.mult (scaleC p.k p.i x q) (Coin.place v.2.2.2.1 (v.2.1/2))
def valuep (x:Word)(a:Ream):ℕ:=
    let v:=(dec a.1:History).1
    p.test.f x (v,p.cell x v a.2)
lemma valueK : Kn p.valuep:= by
    have hp:= ((Kn.unpack (α:=History)).comp (Kn.first (β:=Comb))).left
    have ht:= Kn.next (α:=ℕ) (β:=Comb)
    exact p.test.runs.comp (hp.tuple (Coin.multK ((scaleK p.k p.i).comp hp)
            (Coin.placeK ht.right.right.right.left (ht.right.left.div (Kn.fix 2)))))

def check : Cog := .seq (Cog.ren ⟨_,p.dispatchK⟩ p.one.astir)
                                         (etch _ p.valueK)

def plan (s:Port)(_:ℕ):ℕ:= p.m*s.d
def tariffStart(c:ℕ):= c+p.m+100
def tariff(c:ℕ):= 4*Oven.price (p.tariffStart c)
lemma query {s c t V w} (h:Align s p.k)(hc:1 ≤ c)(ht:t=p.m*s.d)
   (hp:s.Feeds p.p c t w (V/massB p.i s.d))
   {j:ℕ}(hk:Punct s c j)
   (he:j=p.test.f s.l.x (s.info, Coin.mult (scaleC p.k p.i s.l.x s.info) (Coin.place (w t) (2^t)))) :
   Cargo.only0 s (p.tariff c) p.check (s.s 0) (s.s j):= by
   let u:=p.one
   let c1:=p.tariffStart c
   have h1:100 ≤ c1∧c ≤ c1:=by unfold c1 tariffStart; omega
   have hw:s.OK:=h.1
   have he1 : (p.one).Thaw s c1 t (fun b i=>w) (fun b i=> (V/massB p.i s.d)):=by
       refine ⟨h1.1,h.1,by change 0  ≤  _; omega,fun b=>?_,fun b i hi=>?_⟩
       · have hh : (p.one).labels s b ≤ 1:=by cases b <;>exact (by simp [one,Oven.labels])
         have hz:=growing (c1*s.d)
         apply lt_of_le_of_lt hh; have :=hw.1; nlinarith
       exact fewer hp hc h1.2 le_rfl
   have hs := he1.finds le_rfl rfl
   let v:Comb:=(t+1,2^(t+1),0,w t,0)
   have hf : s.comp t (Oven.price c1) p.one.astir (s.s 0) (Pause v s.src):= by
      convert hs using 1
      rw [p.one.finished]
      simp [v,one,Oven.labels,Oven.ext]
   have hz: 1 ≤  Oven.price c1∧ c ≤  Oven.price c1 ∧ p.m ≤  Oven.price c1:=by
      unfold c1 Oven.price Oven.bill tariffStart; omega
   have he0: Cargo.only0 s (p.tariff c) (Cog.ren ⟨_,p.dispatchK⟩ p.one.astir)
                                     (s.s 0) (Pause v s.src):= by
      apply Lot.Mane.pause (t:=t) _ hz.1 h.1.1 h.1.2.1 (ht ▸ Nat.mul_le_mul_right _ hz.2.2)
      exact Cog.renameR _ hf (by simp [dispatch,postcard,h.2.1,ht])
   apply Lot.Mane.seq he0
   refine etches _ _ (i:=v) ?_ he0.spots.2
         (plight (v:=j) (punct_up hk ?_) h.1 ?_)
   · have hu:2^(t+1)/2=(2:ℕ)^t:=by rw [pow_succ]; omega
     simp [v,valuep,postcard,he,hu,cell]
   · unfold tariff; change c ≤ 4*Oven.price c1; omega
   · unfold tariff; change 1 ≤ 4*Oven.price c1; omega

lemma accuracy {s V w t} (h:Align s p.k)(he:Checked w (V/massB p.i s.d) t):
   let x:= Coin.mult (scaleC p.k p.i s.l.x s.info) (Coin.place (w t) (2^t))
   |x.v - V|  ≤  massB p.i s.d * 2/(2:ℝ)^t:=by
   have hp:=abs_le.1 (he.2 t le_rfl)
   let Q:= (2:ℝ)^t; let R:=massB p.i s.d
   have hq:0<Q:=by unfold Q; positivity
   have hr:0<R:=mass0 ..
   dsimp only
   rw [Coin.mul0,Coin.place0 _ _ (Nat.one_le_pow _ _ (by omega)),scalen h]; push_cast
   change |R*((w t:ℝ)/Q)-V| ≤ R*2/Q
   have hf:(0:ℝ) ≤ R/Q:=by positivity
   have hg : R*((w t:ℝ)/Q)-V=(R/Q)*((w t:ℝ)-Q*(V/R)):= by field_simp
   rw [hg,abs_mul,abs_of_nonneg hf]
   rw [show R*2/Q=R/Q*2 by ring]; exact mul_le_mul_of_nonneg_left (he.2 t le_rfl) hf
end Badge
end ExactDerandomization.Fret

end

section

namespace ExactDerandomization.Fret
open Relay Counter Rill Analysis Finset

/-! Uniform simultaneous assurance across all permitted catalytic windings. -/
structure Seats where
    head : Port
    pass0 : ℕ → Prop
    hm : pass0 head.src

namespace Seats
variable (s:Seats)
abbrev d := s.head.d
abbrev l := s.head.l
abbrev info := s.head.info
abbrev seat (x:ℕ):Port:={s.head with src:=x}
def hasOK :=∀ x,s.pass0 x→(s.seat x).OK
def stable (k:Knob) :=∀ x,s.pass0 x → Align (s.seat x) k
abbrev panelx (v:ℕ):Seats:={s with head:={s.head with info:=v}}
abbrev bench (p:Branch)(i:ℕ):Seats:={s with head:=p.port s.head i}

@[simp] lemma home : s.seat s.head.src=s.head := rfl
lemma stable_home {s k} (h:stable s k):Align s.head k:=h _ s.hm
lemma has_home {s} (h:hasOK s):s.head.OK:=h _ s.hm
lemma rocks {s k} (h:stable s k):s.hasOK := fun x hx=>(h x hx).1

def loud (c T i:ℕ)(f:Cog)(V:ℝ)(w:Tape):= ∀ x,s.pass0 x→(s.seat x).Feeds f c T w (V/massB i s.d)
def band (c T i:ℕ)(f:Cog)(V:ℝ) :=∃ w,s.loud c T i f V w
lemma maxv {s c T i f V}(h: band s c T i f V): |V| ≤ massB i s.d:= by
    obtain ⟨w,h⟩:=h; exact amplitude (p:=s.head) (c:=c) (T:=T) (i:=i) (f:=f) ⟨w,h _ s.hm⟩
lemma flex {s c T i f V}(h:band s c T i f V) {D H}(he:1≤c)(hk:c≤D)(hh:H≤T):band s D H i f V:=by
    obtain ⟨w,h⟩:=h; exact ⟨w,fun x hx=> fewer (h x hx) he hk hh⟩
abbrev freq (s:Seats) (p:Branch):=p.S s.head
def full (s:Seats)(p:Branch)(V:ℕ→ℝ)(i c H:ℕ)(f:Cog):=
      p.n.f s.l.x s.info < (2:ℕ)^(p.e*s.d) ∧ ∀ j∈ s.freq p,(s.bench p j).band c H i f (V j)
lemma located {s p i c H f V} (h: full s p V i c H f):∃ w,∀ x,s.pass0 x→ p.Faith (s.seat x) i V c H f w:=by
    classical
    have he(j):∃ w,∀ x,s.pass0 x → ∀ e:j∈s.freq p,
          ((s.bench p j).seat x).Feeds f c H w (V j/massB i s.d):=by
       by_cases hi:j∈s.freq p
       · obtain ⟨w,h1⟩:=h.2 j hi; exact ⟨w,fun x hx _=> h1 x hx⟩
       exact ⟨fun _=>0,fun _ _ hz=> (hi hz).elim⟩
    choose w hw using he
    exact ⟨w,fun x hx=>⟨h.1,fun j e=>hw j x hx e⟩⟩
lemma leasedD {s p i c H f V} (h:full s p V i c H f) (hc:1≤c)(he:hasOK s):
     s.band (powder (Survey.priceB (c+p.e+100))) H i (p.bowl f).poll (rank (s.freq p) V (p.key s.head)):= by
    obtain ⟨w,h⟩:=located h
    exact ⟨fun t=> rankN (s.freq p) (fun j=>(w j t).toNat) (p.key s.head), fun x hx=>
             p.leased (h x hx) hc (he x hx)⟩
lemma rhymeD {s:Seats}{p i c H f V k} (h:s.full p V i c (H+p.reserve*s.d) f) (hc:1≤c)(he:stable s k):
     s.band (powder (Oven.price (p.foldC c))) H (i+p.e) ((p.collect f k i).cooked) (∑ j∈s.freq p,V j):=by
    obtain ⟨w,h⟩:=located h
    exact ⟨(p.collect f k i).out s.head (fun _ j=>w j),fun x hx=> p.poems (h x hx) hc (he x hx)⟩
lemma duetD (p:Bid){s:Seats}{k i j o e c H f g V X} (h:stable s k)(he:p.Fit e i j)(hc:1≤ c)
    (h1:s.band c (H+(e+i+j+6)*s.d) i f V)(h2:s.band c (H+(e+i+j+6)*s.d) j g X)
    (hv:|p.truef V X| ≤ massB o s.d):
    s.band (powder (Oven.price (Bid.joinCost e i j c))) H o (p.uPair k i j o e f g).cooked (p.truef V X):=by
    obtain ⟨w,h1⟩:=h1; obtain ⟨b,h2⟩:=h2
    exact ⟨(p.uPair k i j o e f g).out s.head (fun t _=> if t then w else b),
            fun x hx=> p.fixedjoint (h x hx) he hc (h1 x hx) (h2 x hx) hv⟩

def hear (t c:ℕ)(q:Cog)(v y:ℕ):=∀ x,s.pass0 x→(s.seat x).comp t c q (v,x) (y,x)
abbrev rite (s:Seats)(c:ℕ)(q:Cog)(u:ℕ):=s.hear 0 c q 0 u

lemma avis {s:Seats}{c b q t v i f g} (h: rite s c q b)
    (ha:b=0→s.band c t i g v)(hb:b≠0→s.band c t i f v):
    s.band c t i (Cargo.choose q g f) v:=by
    by_cases hz:b=0
    · obtain ⟨w,hA⟩:=ha hz
      refine ⟨w,fun x hx=>?_⟩
      obtain ⟨ha,ht⟩:=hA x hx
      refine ⟨ha,⟨fun k hk=>?_⟩⟩
      have hc:=Cargo.expands (p:=s.seat x) (h x hx) (t:=k)
      have he:=ht.digits k hk
      refine .seq hc (.yes (show decide (b=0)=true by simp [hz]) (.seq ?_ he))
      exact etches _ _ (i:=b) rfl hc.spots.2 he.spots.1
    obtain ⟨w,hA⟩:= hb hz
    refine ⟨w,fun x hx=>?_⟩
    obtain ⟨ha,ht⟩:=hA x hx
    refine ⟨ha,⟨fun k hk=>?_⟩⟩
    have hc:=Cargo.expands (p:=s.seat x) (h x hx) (t:=k)
    have he:=ht.digits k hk
    refine .seq hc (.no (show decide (b=0)=false by simp [hz]) (.seq ?_ he))
    exact etches _ _ (i:=b) rfl hc.spots.2 he.spots.1

abbrev berth (C:Cub History ℕ)(s:Seats)(b:ℕ):Seats:=s.panelx (C.f s.l.x (s.info,b))

lemma advises {s:Seats}{c b q g C i t v}
   (hp:s.hasOK) (hb:Punct s.head c b)(hc:1≤c)(h:s.rite c q b)
   (ha:(berth C s b).band c t i g v):
    s.band (4*c) t i (Cargo.combine q g C) v:=by
   obtain ⟨w,ha⟩:=ha
   refine ⟨w,fun x hx=>?_⟩
   obtain ⟨hv,he⟩:=ha x hx
   refine ⟨hv,⟨fun k hk=>?_⟩⟩
   have hz:=he.digits k hk
   have ht:=Cargo.aboard (f:=C) (t:=k) (v:=b) (hp x hx) hc hb hz
   have hu := (Cargo.expands (p:=s.seat x) (t:=k) (h x hx)).mono (D:=4*c) (by omega) hc
   refine .seq hu (.seq ht ?_)
   exact etches _ _ (i:=((b,enc (dsign w k)):History)) rfl ht.spots.2
                         (hz.mono (c:=c) (D:=4*c) (by omega) hc).spots.2
end Seats

namespace Lyric
open Seats
inductive Chor (p:Knob)(c T:ℕ) : Seats → Lyric → ℝ → Prop where
   | byear {s r f V} :
       s.band c T r f V → Chor p c T s (.use r f) V
   | played {s i f v}(h:stable s p)(e:Live s.head p T)
       (hz:∀ x,s.pass0 x→ f.f s.l.x (s.info,x)=v)
       (hb: |v.v| ≤ massB i s.d):
          Chor p c T s (.solo i f) v.v
   | doo {s i j A B u o} (h:stable s p)
       (ha:Chor p c T s i A) (hb:Chor p c T s j B) (hr:|u.val A B| ≤ massB o s.d):
              Chor p c T s (.duet u i j o) (u.val A B)
   | little {s q f V b} (h:stable s p)
       (he:q.n.f s.l.x s.info<(2:ℕ)^(q.e*s.d)) (hg:∀ i∈s.freq q,Chor p c T (s.bench q i) f (V i)):
               Chor p c T s (.heap b q f) (if b then ∑ i∈ s.freq q,V i else rank (s.freq q) V (q.key s.head))

lemma sing {p c T s f V}(h:Chor p c T s f V)(hc:1≤c) {H:ℕ} (he:H+f.tail*s.d≤T):
     s.band (f.cost c) H f.weight (choir p f) V := by
   induction h generalizing H with
   | @byear s i q v h=> apply flex h hc le_rfl; exact (Nat.le_add_right ..).trans he
   | @played s i f v h hl hz hb=>
     refine ⟨Brick.tapeR p f i s.head,fun x hx=>?_⟩
     have ht:Brick.tapeR p f i (s.seat x)=Brick.tapeR p f i s.head:=by
         funext j; unfold Brick.tapeR Brick.center
         simp only [postcard,dec_round]
         change Coin.floor0 (Coin.mult _ (Coin.mult (f.f s.l.x (s.info,x)) _)) =
                      Coin.floor0 (Coin.mult _ (Coin.mult (f.f s.l.x (s.info,s.head.src)) _))
         rw [hz x hx,hz _ s.hm]
     rw [← ht]
     have hp:H≤T :=(Nat.le_add_right ..).trans he
     exact Brick.each0 p f i (s.seat x) H (h x hx) ((Nat.pow_le_pow_right Nat.zero_lt_two hp).trans hl)
                      (congrArg Coin.v (hz x hx)) hb
   | @doo s i j A B u o h h1 h2 h3 ia ib=>
     let z:=pulse i.weight j.weight
     let v:= H+z*s.d
     have hp:v+max (tail i) (tail j)*s.d ≤ T:=by
          change H+(z+max i.tail j.tail)*s.d ≤ T at he
          unfold v; rwa [add_mul,← add_assoc] at he
     have hi : v+(tail i)*s.d ≤ T := by
         apply le_trans _ hp
         gcongr; exact le_max_left ..
     have hj : v+(tail j)*s.d ≤ T:=by
         apply le_trans _ hp
         gcongr; exact le_max_right ..
     apply duetD u.ration h (u.legit ..) ((cost_hi (p:=i) hc).trans (le_max_left ..)) _ _ h3
     · exact flex (ia hi) (cost_hi hc) (le_max_left ..) le_rfl
     exact flex (ib hj) (cost_hi hc) (le_max_right ..) le_rfl
   | @little s q f V b h hz hf ih=>
     have hp:s.full q V f.weight (f.cost c) (H+(if b then q.reserve else 0)*s.d) (choir p f):= by
         refine ⟨hz,fun j hj=>ih j hj ?_⟩
         unfold tail at he; rwa [add_mul,← add_assoc] at he
     cases b
     · simp only [choir,cost,weight,Bool.false_eq_true,ite_false]
       simp only [Bool.false_eq_true,ite_false,zero_mul,add_zero] at hp
       exact leasedD hp (cost_hi hc) (rocks h)
     simp only [choir,cost,weight,ite_true]
     exact rhymeD hp (cost_hi hc) h

lemma Chor.nominal {p c T s f V}(h:Chor p c T s f V):Lethe p c T s.head f V:=by
    induction h with
    | @byear s r f V h=>
      obtain ⟨w,h⟩:=h; exact .byear ⟨w,h _ s.hm⟩
    | @played s i f v h e hz hb=>
      have hu:f.f s.l.x (s.info,s.head.src)=v:=hz _ s.hm
      subst v; exact .played (stable_home h) e hb
    | doo h _ _ hi ih ik=> exact .doo (stable_home h) ih ik hi
    | little h he _ hi=> exact .little (stable_home h) he hi
lemma Chor.minuet {p c T s i j A B}(h:Chor p c T s i A)(e:Chor p c T s j B) (hs:stable s p)(op:Doop):
    Chor p c T s (bi op i j) (op.val A B):=
   .doo hs h e (op.geom _ _ s.d (stable_home hs).1.1 h.nominal.bnd e.nominal.bnd)

end Lyric
end ExactDerandomization.Fret

end

section

namespace ExactDerandomization.Fret
open Relay Counter Rill Analysis Finset

namespace Seats
lemma higher {s c t q x y i} (h:hear s t c q x y)(hp:1 ≤ c)(he:c ≤ i):hear s t i q x y:=
   fun x hx=>(h x hx).mono he hp
lemma pointed0 {s c v k} (hp:hasOK s) (he:2 ≤ c)(ht:Punct s.head c v)(hz:Punct s.head c k):
   s.hear 0 c (etch (α:=ℕ) (fun _ _=>k) (Kn.fix _)) v k:=fun x hx=>
   etches _ _ (i:=v) rfl (plight ht (hp x hx) (by omega)) (plight hz (hp x hx) (by omega))
abbrev nothingX := Cargo.knock
lemma blankD {s c}(h:hasOK s)(he:2 ≤ c):s.rite c nothingX 0:=
   pointed0 h he (punct0 (has_home h) he) (punct0 (has_home h) he)

lemma steer {s c z q f g b} (h:rite s c q z)
    (ha:z=0→s.rite c f b)(hb:z≠0→s.rite c g b):
    s.rite c (Cargo.choose q f g) b:=by
   intro x hx
   have hu:=Cargo.expands (p:=s.seat x) (h x hx) (t:=0)
   by_cases he:z=0
   · have hz:=ha he x hx
     exact .seq hu (.yes (show decide (z=0)=true by simp [he])
             (.seq (etches _ _ (i:=z) rfl hu.spots.2 hz.spots.1) hz))
   have hz:=hb he x hx
   exact .seq hu (.no (show decide (z=0)=false by simp [he])
            (.seq (etches _ _ (i:=z) rfl hu.spots.2 hz.spots.1) hz))
abbrev transformed (P:Cub ℕ ℕ)(f:Cog) := Cog.ren ⟨_,Cargo.switchK P⟩ f
lemma importD (P:Cub ℕ ℕ){s:Seats}{t c q x y v}(e:P.f s.l.x s.info=v)
    (h:hear (panelx s v) t c q x y):s.hear t c (transformed P q) x y:=by
   intro z hz
   refine Cog.renameR _ (h z hz) ?_
   change Cargo.switch P s.l.x _=postcard v t
   simp [Cargo.switch,postcard,e]
lemma transportD (P:Cub ℕ ℕ){s:Seats}{T i f c x v}(e:P.f s.l.x s.info=v)
   (h:band (panelx s v) c T i f x):s.band c T i (transformed P f) x:=by
   obtain ⟨w,h⟩:=h
   have hh(t:ℕ)(ht:t ≤ T):hear (panelx s v) t c f 0 (enc (dsign w t)):=
       fun z hz=>(h z hz).2.digits t ht
   exact ⟨w,fun z hz=> ⟨(h z hz).1,⟨fun t ht=>importD P e (hh t ht) z hz⟩⟩⟩

end Seats

open Seats

/-- Pick the zero-based kth nonzero answer; the pair of index and answer is positive, or 0 if none. -/
structure Seek where
    b:Branch
    mask:Cog

namespace Seek
variable (s:Seek)
abbrev bin (i z:ℕ):ℕ := enc (i,z)
lemma binpos (i z) : 0<bin i z:=lt_trans Nat.zero_lt_one (cord_fine _ _).2.2
abbrev SeqN := ℕ×ℕ
def transfer (k i x:ℕ) (v:SeqN):SeqN:=
   if x=0 then v else (v.1+1,if v.1=k then bin i x else v.2)

def relief (v:ℕ→ ℕ)(k:ℕ):ℕ→SeqN
    | 0=>(0,0)
    | i+1=>transfer k i (v i) (relief v k i)
def part (v:ℕ→ℕ)(i:ℕ): Finset ℕ:= (range i).filter fun j=>v j≠0

lemma heightp (v k i):(relief v k i).1 = (part v i).card:=by
   induction i with
   | zero=>simp [relief,part]
   | succ i ih=>
     have hh : part v (i+1) = if v i ≠ 0 then insert i (part v i) else part v i:=by
                   unfold part; rw [range_add_one,filter_insert]
     by_cases he:v i=0
     · simp [relief,transfer,he,ih,hh]
     have hm:i ∉ part v i:=by simp [part]
     simp [relief,transfer,he,ih,hh,hm]
lemma countle (v i):(part v i).card  ≤  i:=by simpa [part] using card_filter_le (range i) (fun j=>v j≠0)
lemma catalogs {v:ℕ→ℕ}{i j:ℕ}(h:i ≤ j):part v i ⊆ part v j:=by unfold part; gcongr
lemma ticket {v:ℕ→ℕ}{k i:ℕ} (hi:i<k)(he:v i≠0): (part v i).card < (part v k).card:=by
    apply card_lt_card
    rw [Finset.ssubset_iff_subset_ne]
    refine ⟨catalogs hi.le,fun h=>?_⟩
    have hm:i∈part v k:=by simp [part,hi,he]
    rw [← h] at hm; simp [part] at hm
lemma order {v:ℕ→ℕ}{k i j:ℕ}(hi:i<j) (he:v i≠0)(ht:(part v i).card=k):
     (relief v k j).2=bin i (v i):=by
    induction hi with
    | refl=> simp only [relief,transfer,ite_eq_right he,heightp,ht,ite_true]
    | @step j hi ih=>
      have hh : (relief v k j).1≠ k:=by rw [heightp,← ht]; exact ne_of_gt (ticket hi he)
      simp only [relief,transfer,hh,ite_false]
      split <;> exact ih
lemma found_min {v:ℕ→ℕ}{k j:ℕ} (ht:k < (part v j).card):
    ∃ i∈part v j, (part v i).card=k:=by
   induction j with
   | zero=>simp [part] at ht
   | succ j ih=>
     by_cases he:k < (part v j).card
     · obtain ⟨i,h,e⟩:=ih he; exact ⟨i,catalogs (by omega) h,e⟩
     rw [←heightp v k] at he ht
     rw [relief,transfer] at ht
     split at ht
     · contradiction
     next h=>
       refine ⟨j,by simp [part,h],?_⟩
       dsimp only at ht; simp_rw [heightp] at ht he; omega
lemma missed {v:ℕ→ℕ}{k j:ℕ}: (relief v k j).2=0 ↔ (part v j).card  ≤  k:=by
   constructor
   · intro h; by_contra! hc
     obtain ⟨i,hx,hv⟩:=found_min hc
     obtain ⟨hx,hz⟩:=mem_filter.1 hx
     rw [order (mem_range.1 hx) hz hv] at h; have := binpos i (v i); omega
   intro h
   induction j with
   | zero=>rfl
   | succ j ih=>
      have he:(relief v k j).2=0:=ih (le_trans (card_le_card (catalogs (by omega))) h)
      by_cases hs:v j=0
      · simpa [relief,transfer,hs]
      have hv : (part v j).card<k:=lt_of_lt_of_le (ticket (k:=j+1) (by omega) hs) h
      simp [relief,transfer,hs,heightp,ne_of_lt hv,he]

lemma casebook (v k i):(relief v k i).2=0 ∨ ∃ j∈part v i,
                (part v j).card=k ∧ (relief v k i).2=bin j (v j):=by
   rcases le_or_gt (part v i).card k with hh|hh
   · exact Or.inl (missed.2 hh)
   obtain ⟨j,h1,h2⟩:=found_min hh; obtain ⟨hx,he⟩:=mem_filter.1 h1
   exact Or.inr ⟨_,h1,h2,order (mem_range.1 hx) he h2⟩

abbrev grainK {α} [Wire α] {p g f:PT α ℕ} {q:PT α SeqN}
   (hp:Kn p)(hg:Kn g)(hf:Kn f)(hq:Kn q): Kn (fun x a=> transfer (p x a) (g x a) (f x a) (q x a)):= by
    have hi:=Kn.wash (α:=SeqN)
    have hh:Kn (fun x a=> if (q x a).1=p x a then bin (g x a) (f x a) else (q x a).2):=
       by simpa only [decide_eq_true_eq] using ((hq.left.eq hp).cond (hi.comp (hg.tuple hf)) hq.right)
    simpa only [transfer,decide_eq_true_eq] using ((hf.eq (Kn.fix 0)).cond hq (hq.left.succ.tuple hh))

def fill (x:Word)(a:Camp.Info):ℕ:=
   let (i,r):History:=dec a.2.1
   binBoth (transfer (s.b.k.f x a.1) i a.2.2 (dec r))
 where binBoth (v:SeqN) := enc v
lemma fillK:Kn s.fill:= by
   have h:= (Kn.unpack (α:=History)).comp (Kn.next (β:=History) (α:=ℕ)).left
   exact Kn.wash.comp (grainK (s.b.k.runs.comp Kn.first) h.left Kn.next.right (Kn.unpack.comp h.right))

def road (x:Word)(a:History):ℕ:= s.b.route.f x (a.1,(dec a.2:History).1)
lemma roadK:Kn s.road:=
   s.b.route.runs.comp (Kn.first.tuple ((Kn.unpack (α:=History)).comp Kn.next).left)

def tent :Camp:=⟨s.b.n,⟨_,s.roadK⟩,s.mask,⟨_,s.fillK⟩⟩
def latch := Cog.seq (etch (α:=ℕ) (fun _ _=>((0,0):SeqN)) (Kn.fix _)) (.seq s.tent.walk0
                (etch (α:=SeqN) (fun _ a=>a.2.2) Kn.next.right))
variable (p:Seats)
abbrev N:=s.b.n.f p.l.x p.info

lemma earns {c}{p:Seats} (h:p.hasOK)(hc:2 ≤ c)(v:ℕ→ ℕ)
     (he:Punct p.head c (s.N p))
     (hp:∀ i<s.N p,Punct p.head c (v i) ∧ (p.bench s.b i).rite c s.mask (v i)):
    let z:=(relief v (s.b.key p.head) (s.N p)).2
    Punct p.head (4*c) z ∧ p.rite (16*(16*c)) s.latch z:=by
   let k:=s.b.key p.head; let m:=s.N p; let w:= relief v k
   have ha:= has_home h
   have hk(i)(hi:i ≤ m) : Punct p.head c i:=by
            unfold Punct; exact le_trans (Nat.add_le_add_right (lb_mono hi) _) he
   have hw(i)(hi:i ≤ m) : Punct p.head (4*c) (w i).2:=by
      rcases casebook v k i with hh|⟨j,h1,-,hg⟩
      · change (w i).2=0 at hh; rw [hh]; exact punct0 ha (by omega)
      change (w i).2=bin j _ at hg; rw [hg]; have he:=lt_of_lt_of_le (mem_range.1 (mem_filter.1 h1).1) hi
      exact holdroom ha (hk j he.le) (hp j he).1
   have hh (i)(hi:i ≤ m): Punct p.head (16*c) (enc (w i)):=by
        have ht : (w i).1 ≤ m:=by change (relief v k i).1 ≤ m; rw [heightp]; exact (countle ..).trans hi
        have he:= holdroom ha (punct_up (hk _ ht) (show c ≤ 4*c by omega)) (hw i hi)
        convert he using 1 ; grind
   dsimp only; refine ⟨hw m le_rfl,fun x hx=>?_⟩
   have hz:=h x hx
   have hr:=s.tent.round (t:=0) (p:=p.seat x) hz (by omega:2 ≤ 16*c) (fun i=>enc (w i)) v rfl
        (vscale he) (fun i hi=>hh i hi) (show ∀ i < s.tent.n0 (p.seat x),
        _ from fun i hi=> by
          have hn:i < m:=hi
          have hs:= ((hp i hn).2 x hx).mono (D:=16*c) (by omega) (by omega)
          constructor
          · unfold Camp.poster tent fill; simp only [dec_round]; rfl
          convert hs using 1 <;> simp [Cargo.transit,tent,road,seat,Branch.port])
   unfold Port.comp at *
   refine .seq (etches _ _ (i:=0) rfl ?_ hr.spots.1) (.seq hr
              (etches _ _ (i:=w m) rfl hr.spots.2 ?_))
   · exact plight (punct0 hz (by omega)) hz (by omega)
   exact plight (punct_up (hw m le_rfl) (by omega)) hz (by omega)
 where
    vscale {c n p}(e:Punct p c n): Punct p (16*c) n:=punct_up e (by omega)
end Seek
end ExactDerandomization.Fret

end

end OAI