import OAI.Computability.Logspace.CompressionPrograms
import OAI.Computability.Logspace.ProbabilityAtoms

namespace OAI

/-!
Sparse row encodings, slot selection, and virtual baselines.

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

set_option autoImplicit true

section

namespace ExactDerandomization.Stem
open Counter Relay Rill Fret Reed Analysis Hie At Finset Seats Buf

/-- A row with bounded ports and virtual baseline. -/
structure Depot where
    S:Domain
    y:Blob
    n:ℕ
    tag:ℕ→ℕ
    pos:ℕ→ℕ
namespace Depot
noncomputable section
variable (p:Depot)
abbrev live(i:ℕ):Prop:=p.tag i≠0
def space:= (range p.n).filter p.live
def qpoint(i:ℕ):Pt:= if p.live i then p.y.ts (p.pos i) else line p.y.base
structure Trust:Prop where
    hp:0  ≤  p.y.base
    card0:∀ i,p.live i→ i < p.n
    into:∀ i,p.live i→ p.pos i∈ p.S
    uniq:∀ i j,p.live i→p.live j→p.pos i=p.pos j→i=j
    off:∀ i∈p.S,(∀ j,p.live j→p.pos j≠i) → p.y.ts i=line p.y.base
namespace Trust
variable {p:Depot}(h:p.Trust)
include h
lemma seen (i):i∈p.space ↔ p.live i:= by rw [space,mem_filter]; exact
       ⟨fun e=>e.2,fun e=>⟨mem_range.2 (h.card0 i e),e⟩⟩

lemma snatch {i} (hi:i∈p.S)(hh:p.y.ts i ≠ line p.y.base):∃ j,p.live j∧p.pos j=i:= by
   by_contra! hp
   exact hh (h.off i hi (fun j he hx=> hp j he hx))

abbrev coast (p:Depot) (K:ℕ) :=
       max (rank (range p.n) (fun i=> (p.qpoint i).1) K) p.y.base
lemma coast_true (K): p.y.rk p.S K=coast p K:= by
   let b:=p.y.base; let s:=p.space
   let f(i):=(p.qpoint i).1
   let g(i):=(p.y.ts i).1
   have hv {x:ℝ} (hx:b ≤ x):
        ((range p.n).filter (fun i=> x< f i)).card=(p.S.filter (fun i=> x< g i)).card:=by
      let l:=(range p.n).filter (fun i=>x<f i); let w:=p.S.filter (fun i=> x< g i)
      have hh (i)(hi:i∈l):p.live i ∧ f i=g (p.pos i):=by
         by_cases ht:p.live i
         · exact ⟨ht,congrArg Prod.fst (ite_eq_left ht)⟩
         have hh:f i=b:=congrArg Prod.fst (show p.qpoint i=line p.y.base from ite_eq_right ht)
         have hl:x<f i:=(mem_filter.1 hi).2; linarith
      have he: l.image p.pos=w:=by
          ext i; constructor
          · intro ht; obtain ⟨j,h1,rfl⟩:=mem_image.1 ht
            exact mem_filter.2 ⟨h.into j (hh j h1).1,(mem_filter.1 h1).2.trans_eq (hh j h1).2⟩
          intro ht; obtain ⟨ha,hb⟩:=mem_filter.1 ht
          have he:p.y.ts i ≠ line p.y.base:=fun hg=> (not_lt_of_ge hx)
                                                        (hb.trans_eq (congrArg Prod.fst hg))
          obtain ⟨j,h1,h2⟩:=h.snatch ha he
          have hs:f j=g (p.pos j):=congrArg Prod.fst (show p.qpoint j=p.y.ts (p.pos j) from ite_eq_left h1)
          rw [h2] at hs
          exact mem_image.2 ⟨j,mem_filter.2 ⟨mem_range.2 (h.card0 j h1),hb.trans_eq hs.symm⟩,h2⟩
      rw [← show l.image p.pos=p.S.filter _ from he]
      symm; refine card_image_iff.2 (fun i hi j hj hz=>h.uniq i j (hh i hi).1 (hh j hj).1 hz)
   let u:=max (rank p.S g K) b
   let v:=coast p K
   have hh(x:ℝ) : (x<u)↔ x<v:=by
      change x < max (rank p.S g K) b ↔ x < max (rank (range p.n) f K) b
      by_cases ht:b ≤ x
      · rw [lt_max_iff,lt_max_iff]; have hg:=h.hp.trans ht
        rw [rank_gt hg,rank_gt hg,hv ht]
      have ht:x<b:=by linarith
      simp [lt_max_iff,ht]
   change u=v; rcases lt_trichotomy u v with he|he|he
   · exact False.elim (lt_irrefl _ ((hh u).2 he))
   · exact he
   exact False.elim (lt_irrefl _ ((hh v).1 he))

structure ColorF (p:Depot) where
    tau:ℝ
    K:ℕ
    kth:ℝ
    pts:ℕ → ℝ
open scoped Classical
def ColorF.mapG (p:Depot)(c: ColorF p):Blob.Guess:=
    ⟨fun i=> if h:∃ j,p.live j ∧ p.pos j=i then c.pts (Classical.choose h) else (p.y.ts i).1,c.kth⟩
variable {z:ColorF p}
def GoodS(c:ColorF p):= (∀ i,p.live i→|(p.qpoint i).1 - c.pts i|  ≤  c.tau/10000)∧ |coast p c.K-c.kth|  ≤  c.tau/10000
def ColorF.hoot (p:Depot)(v:ColorF p) (b:Bool)(i:ℕ):Prop:=p.live i ∧
   if b then v.tau/5 < v.pts i ∧ v.kth < v.tau*(15/1000) else
             5*v.tau/12 < v.pts i ∧ v.kth < v.tau*(35/10000)

lemma restates {i}(he:p.live i): (ColorF.mapG p z).first (p.pos i)=z.pts i:=by
   have hh:∃ j,p.live j∧p.pos j=p.pos i:=⟨i,he,rfl⟩
   simp only [ColorF.mapG,dite_eq_left hh]
   obtain ⟨ht,hz⟩:= Classical.choose_spec hh; rw [h.uniq (Classical.choose hh) _ ht he hz]

lemma region (c:GoodS z)(he:0< z.tau):
     Blob.acc (ColorF.mapG p z) p.y p.S z.K z.tau:=by
   refine ⟨fun i hi=>?_,(h.coast_true z.K).symm ▸ c.2⟩
   unfold ColorF.mapG; dsimp only
   split
   · next hp=>
     obtain ⟨ha,hb⟩:= Classical.choose_spec hp
     have hu:=c.1 _ ha
     unfold qpoint at hu; rw [ite_eq_left ha,hb] at hu
     exact hu
   simp only [sub_self,abs_zero]; positivity

lemma onward {c:ColorF p}(z:GoodS c)(he:0<c.tau) (b:Bool):
    Blob.expose c.tau (ColorF.mapG p c) b p.S =
        ((range p.n).filter (ColorF.hoot p c b)).image p.pos:=by
    let D:= Blob.expose c.tau (ColorF.mapG p c) b p.S
    have ht {i}(hh:p.live i): p.pos i∈D↔ColorF.hoot p c b i:=by
       have he:= h.into i hh
       cases b <;> unfold D <;>
           simp only [Blob.expose,ColorF.hoot,h.restates hh,he,show (ColorF.mapG p c).kth=c.kth from rfl,mem_filter,Bool.false_eq_true,ite_false,ite_true] <;> grind
    change D=_
    ext i; constructor
    · intro hz
      have hi:i∈p.S:= Blob.expose_subset p.S _ _ _ hz
      have hF: p.y.ts i≠ line p.y.base:=by
          intro hh
          exact Blob.missing_baseline (h.region z he) he b (congrArg Prod.fst hh) hz
      obtain ⟨j,hv,rfl⟩:=h.snatch hi hF
      exact mem_image.2 ⟨j,mem_filter.2 ⟨mem_range.2 (h.card0 j hv),(ht hv).1 hz⟩,rfl⟩
    intro hi; obtain ⟨j,hv,rfl⟩:=mem_image.1 hi
    exact (ht (mem_filter.1 hv).2.1).2 (mem_filter.1 hv).2

lemma amount0 {c:ColorF p}(hc:GoodS c)(he:0<c.tau)(b:Bool):
    ((range p.n).filter (ColorF.hoot p c b)).card  ≤  c.K:=by
   have hv:=Blob.exposure_count (h.region hc he) he b
   rw [h.onward hc he b,card_image_iff.2] at hv
   · exact hv
   intro i hi j hj ht
   exact h.uniq _ _ (mem_filter.1 hi).2.1 (mem_filter.1 hj).2.1 ht
end Trust
end
end Depot
end ExactDerandomization.Stem

end

section

namespace ExactDerandomization.Stem
open Counter Relay Rill Fret Reed Analysis Hie At Finset Seats Buf Lu Depot.Trust
open Lyric
noncomputable section
/- main (b=false) weight argument o. b=true witness uses score I,
not the upper guarding score. -/
structure Cage where
     m: ℕ
     k:ℕ
     powe: ℕ
     lo:ℕ
     kn:Knob
     base:Cog
     ask : Cog
     partR : Bool → Cog
     theta:Cub ℕ Coin
     nest:Bool→ Lyric→Lyric→ Lyric → Lyric
     root : Bool → ℕ

namespace Cage
variable (p:Cage)
abbrev firstC(b:Bool):Lyric:=.use p.powe (p.partR b)
abbrev fellow (k:Cub ℕ ℕ):Branch:=⟨⟨_,Kn.fix p.m⟩,⟨_,stairK true⟩,k,p.m+2⟩
abbrev relay0:=p.fellow ⟨_,Kn.fix p.k⟩
abbrev crown:Lyric:= Lu.sup (.use p.powe p.base) (.heap false p.relay0 (p.firstC true))
abbrev figure (b:Bool):Lyric:=p.nest b (p.firstC true) p.crown (p.firstC false)

variable (s: Seats) (d:Depot)(θ:ℝ)(o:Bool→Trio) (c T:ℕ)
/-- birth chamber precondition -/
structure Ink : Prop where
     ok:d.Trust
     align:s.stable p.kn
     goodF : ∀ i j, (film s i j).stable (campk p.kn)
     hi:s.d=1
     mp:d.n=p.m
     hc:4 ≤ c
     expire:Live s.head p.kn T
     θp : (massB p.lo s.d)⁻¹  ≤  θ/20000
     θq : ∀ i,(p.theta.f s.l.x (film s i 0).info).v=θ
     get:∀ i<p.m,(film s i 0).rite c p.ask (d.tag i) ∧ Punct s.head c (d.tag i)
     srcT :∀ i,i=0∨i<p.m → (film s i 0).band c T p.powe p.base d.y.base
     hues :∀ i<p.m,∀ b,(film s i 0).band c T p.powe (p.partR b) (sideq (d.qpoint i) b)
     seats0:∀ b,(p.figure b).weight=p.root b
     composition :∀ {i} (_:i<p.m),d.live i→ ∀ b,
          Chor (campk p.kn) c T (film s i 0) (p.firstC true) (d.y.ts (d.pos i)).1 →
          Chor (campk p.kn) c T (film s i 0) p.crown (d.y.rk d.S p.k) →
          Chor (campk p.kn) c T (film s i 0) (p.firstC false) (d.y.ts (d.pos i)).2 →
          Chor (campk p.kn) c T (film s i 0) (p.figure b) (d.y.val d.S p.k (o b) (d.pos i))

abbrev ratioX (b f:Bool):Coin:=
    if b then if f then Coin.place 1 5 else Coin.place 15 1000 else
      if f then Coin.place 5 12 else Coin.place 35 10000
def probeX (b f:Bool)(x:Word)(a:ℕ×Coin):ℕ:=
   let k:=Coin.mult (p.theta.f x a.1) (ratioX b f)
   if (if f then Coin.low a.2 k else Coin.low k a.2) then 0 else 1
lemma probeK (b f):Kn (p.probeX b f):=by
    have ht:Kn (fun x (a:ℕ×Coin)=>Coin.mult (p.theta.f x a.1) (ratioX b f)):=
                                  Coin.multK (p.theta.runs.comp Kn.first) (Kn.fix _)
    cases f
    · exact ((Coin.lowerK ht Kn.next).cond (Kn.fix 0) (Kn.fix 1))
    exact ((Coin.lowerK Kn.next (Coin.multK (p.theta.runs.comp Kn.first)
                                        (Kn.fix _))).cond (Kn.fix 0) (Kn.fix 1))
abbrev realkey(f:Bool):Lyric:= if f then p.firstC true else p.crown
abbrev pin (p:Cage)(f:Bool):=Reed.Test.draw (p.realkey f) p.lo
def badge0 (b f:Bool):Badge:=
   let k:=campk p.kn
   let u:=p.realkey f
   ⟨u.choir k,k,u.weight,p.pin f,⟨_,p.probeK b f⟩⟩

namespace Ink
variable {p s d θ o c T}(h:Ink p s d θ o c T)
include h
private lemma crew (i j) : Lu.Standard (film s i j) (campk p.kn) T:=
    ⟨h.goodF i j,spanFilm h.expire ..⟩

omit h in
lemma fix0(i j a): (film s i j).bench (p.relay0) a=film s a 0:=by
                simp [film,bench,Branch.port,panelx,stairs]
lemma crowny {i} (he:i=0∨i<p.m):Chor (campk p.kn) c T (film s i 0) p.crown (d.y.rk d.S p.k) := by
    have hv : (film s i 0).freq p.relay0=range d.n:=by rw [h.mp]
    let F:=fun i=>(d.qpoint i).1
    have he0 : Chor (campk p.kn) c T (film s i 0) (.heap false p.relay0 (p.firstC true)) (rank (range d.n) F p.k):=by
       rw [← hv]
       apply Chor.little (h.goodF i 0)
       · change p.m < 2^((p.m+2)*s.d)
         rw [h.hi,mul_one]; have hz:= Relay.growing (p.m+2); omega
       intro a hz
       rw [hv,h.mp] at hz
       rw [(fix0 (p := p) (s := s))]
       exact .byear (h.hues a (mem_range.1 hz) true)
    rw [h.ok.coast_true]
    unfold coast; rw [max_comm]
    exact (h.crew ..).up0 (.byear (h.srcT i he)) he0

lemma sculpt {i} (hi:d.live i) (b):
    Chor (campk p.kn) c T (film s i 0) (p.figure b) (d.y.val d.S p.k (o b) (d.pos i)) := by
   have hn:i<p.m:=(h.ok.card0 i hi).trans_eq h.mp
   have ht : d.qpoint i=d.y.ts (d.pos i):= ite_eq_left hi
   apply h.composition hn hi b _ (h.crowny (Or.inr hn)) _
   · rw [← ht]; exact .byear (h.hues i hn true)
   rw [← ht]; exact .byear (h.hues i hn false)
end Ink

abbrev Peer(f:Bool):= Test.extra (p.realkey f) p.lo
abbrev gauge (f:Bool)(c:ℕ):= (Test.seatC (p.realkey f) c)
abbrev goodz (c:ℕ):= c + p.m + 8
abbrev tolls (f:Bool)(c:ℕ):= (p.badge0 false f).tariff (p.gauge f c)
abbrev OutC(c:ℕ) :=p.goodz c+p.tolls false c+p.tolls true c

def voice (p:Cage)(b:Bool) := Cargo.choose
        (transformed ⟨_,centerK⟩ (p.badge0 b false).check)
        Seats.nothingX (Cargo.choose (p.badge0 b true).check Seats.nothingX p.ask)
namespace Ink
variable {p s d θ o c T}(h:Ink p s d θ o c T)
include h
omit h in
private lemma probeB (b f:Bool) (i x):p.probeX b f s.l.x ((film s i 0).info,x)  ≤ 1:=by
   cases f <;> simp [probeX] <;> grind
lemma orb {f q}(hq:Test.extra (p.realkey f) p.lo*s.d ≤ T){X:ℝ}
   (hx:Chor (campk p.kn) c T (film s q 0) (p.realkey f) X):
    ∃ a:Coin, |X-a.v|  ≤  θ/10000 ∧ ∀ b,(film s q 0).rite (p.tolls f c) (p.badge0 b f).check
                                              (p.probeX b f s.l.x ((film s q 0).info,a)):=by
   let m:=film s q 0; let v:=p.realkey f
   have hM:1 ≤ c:=by have:=h.hc; omega
   let C:= p.gauge f c; let H:=p.pin f*s.d
   obtain ⟨w,h0⟩:=flex (sing hx hM (H:=H) (by
         unfold Test.extra at hq; rw [add_mul] at hq; exact hq))
          (Lyric.cost_hi hM) (show v.cost c ≤ C by unfold C gauge Test.seatC v; omega) le_rfl
   let Y:=Coin.mult (scaleC (campk p.kn) v.weight m.l.x m.info) (Coin.place (w H) (2^H))
   have hm:= (h.crew q 0).st; have hi:=stable_home hm
   have hz:(p.badge0 true f).i=v.weight:=rfl
   have ht:= (p.badge0 true f).accuracy hi (h0 _ m.hm).1
   change |Y.v-X|  ≤  massB v.weight s.d*2/(2:ℝ)^H at ht
   have hd:1 ≤ s.d := h.hi.ge
   have he : |Y.v-X| < (massB p.lo s.d)⁻¹/2:= lt_of_le_of_lt ht (Test.f_marg s.d v.weight p.lo hd)
   have hg := h.θp; have hp:0<(massB p.lo s.d)⁻¹ :=by positivity
   refine ⟨Y,?_,fun b x hh=>?_⟩
   · rw [abs_sub_comm]; linarith
   let i:=p.probeX b f s.l.x (m.info,Y)
   have hP : lb i  ≤ 1:= by exact lb_mono ((probeB (p := p) (s := s)) b f q Y)
   have hv:4 ≤ C:=by unfold C gauge Test.seatC; omega
   exact (p.badge0 b f).query (hm x hh) (by  omega)
                    (t:=H) rfl (h0 x hh) (show Punct (m.seat x) C i by
                         unfold Punct; change _+_ ≤ C*s.d; nlinarith) rfl
lemma asks {q v b f}:
      p.probeX b f s.l.x ((film s q 0).info,v)≠0 ↔
        if f then θ*(ratioX b f).v < v.v else v.v < θ*(ratioX b f).v:=by
   cases f <;> unfold probeX <;> simp [Coin.low_eq,h.θq]

end Ink
end Cage
end
end ExactDerandomization.Stem

end

section

namespace ExactDerandomization.Stem.Cage
open Counter Relay Rill Fret Reed Analysis Hie At Finset Seats Buf Lu Depot.Trust
open Lyric
noncomputable section
open scoped Classical
variable (p:Cage) (s:Seats) (d:Depot)(θ:ℝ)(o:Bool→Trio) (c T:ℕ)

structure Ballot where
    wt : ColorF d
def Game (_:Cage)(d:Depot)(u:Ballot d)(b:Bool)(i:ℕ):ℕ:= if ColorF.hoot d u.wt b i then d.tag i else 0
def shaft (b:Bool):Seek:=⟨p.fellow leftQ,p.voice b⟩
abbrev belt (b:Bool):Cog:=(p.shaft b).latch
abbrev valN(p:Cage)(d:Depot)(u:Ballot d)(b:Bool)(i:ℕ):ℕ:=(Seek.relief (Game p _ u b) i p.m).2

structure Style(u:Ballot d):Prop where
   rightP:u.wt.K=p.k
   height:u.wt.tau=θ
   legally: GoodS u.wt
   serve:∀ i<p.m,∀ b,(film s i 0).rite (p.OutC c) (p.voice b) (Game p d u b i)∧
                                                Punct s.head (p.OutC c) (Game p d u b i)
namespace Ink
variable {p s d θ o c T}(h:Ink p s d θ o c T)
include h
lemma ht0 : 0<θ:=by
   have hp:0<(massB p.lo s.d)⁻¹:=by positivity
   have hv:=h.θp; linarith
lemma colorBlock {i} (v w: Coin)(b:Bool){z:Ballot d}(hp:z.wt.tau=θ)(hf:z.wt.kth=w.v)(hy:z.wt.pts i=v.v):
   z.wt.hoot d b i ↔
     d.live i ∧ p.probeX b true s.l.x ((film s i 0).info,v)≠0
                ∧ p.probeX b false s.l.x ((film s 0 0).info,w)≠0:=by
   rw [h.asks (q:=i),h.asks (q:=0)]
   unfold ColorF.hoot
   rw [hp,hf,hy]
   cases b
   · simp only [Bool.false_eq_true,ite_false,ite_true,ratioX]
     rw [Coin.place0 _ _ (by norm_num),Coin.place0 _ _ (by norm_num)]; norm_num; ring_nf; simp
   simp only [ite_true,ratioX, Bool.false_eq_true,ite_false]
   rw [Coin.place0 _ _ (by norm_num),Coin.place0 _ _ (by norm_num)]; norm_num; ring_nf; simp

lemma cost_vol(b:Bool):1 ≤  c∧c ≤ p.OutC c∧2 ≤ p.OutC c∧1  ≤ p.tolls b c∧p.tolls b c  ≤ p.OutC c:=by
   have hz:=h.hc
   cases b <;> unfold OutC goodz tolls Badge.tariff Oven.price Oven.bill Badge.tariffStart <;> omega

abbrev prepare(p:Cage):=p.Peer false+p.Peer true
lemma chose (hp:prepare p*s.d ≤ T):∃ u,Style p s d θ c u:= by
    let f(i:ℕ):=(d.qpoint i).1
    let v:= coast d p.k
    have hP:p.Peer false*s.d ≤ T ∧ p.Peer true*s.d ≤ T:=by unfold prepare at hp; rw [add_mul] at hp; omega
    have hs:Chor (campk p.kn) c T (film s 0 0) (p.realkey false) v:=by
       unfold v; rw [← h.ok.coast_true p.k]; exact h.crowny (Or.inl rfl)
    obtain ⟨w,hU,hW⟩:=h.orb (f:=false) hP.1 hs
    have he(i:ℕ):∃ w:Coin,i<p.m→ |f i-w.v|  ≤  θ/10000 ∧ ∀ b,(film s i 0).rite (p.tolls true c)
                                    (p.badge0 b true).check (p.probeX b true s.l.x ((film s i 0).info,w)):=by
       by_cases hi:i<p.m
       · obtain ⟨w,h⟩:=h.orb (f:=true) (X:=f i) hP.2 (Chor.byear (h.hues i hi true))
         exact ⟨w,fun _=>h⟩
       exact ⟨Coin.ofZ 0,fun h=> (hi h).elim⟩
    choose wt hw using he
    let u:Ballot d:=⟨⟨θ,p.k,w.v,fun i=>(wt i).v⟩⟩
    refine ⟨u,rfl,rfl,⟨fun i hi=>(hw i ((h.ok.card0 i hi).trans_eq h.mp)).1,hU⟩,fun i hi b=>?_⟩
    let x:=film s i 0
    have hg:= h.get i hi
    have hz:= (h.colorBlock (wt i) w b (z:=u) (i:=i) rfl rfl rfl)
    have hl:= h.cost_vol false; have hr:=h.cost_vol true
    have ha:x.rite (p.OutC c) (transformed ⟨_,centerK⟩ (p.badge0 b false).check)
                  (p.probeX b false s.l.x ((film s 0 0).info,w)):=importD _ (Board.centeral s i 0)
                                     (higher (hW b) hl.2.2.2.1 hl.2.2.2.2)
    have hb:=higher ((hw i hi).2 b) hr.2.2.2.1 hr.2.2.2.2
    have hh:= Seats.blankD (rocks (h.goodF i 0)) hl.2.2.1
    unfold Game; split
    · next e=>
      obtain ⟨h1,h2,h3⟩:=hz.mp e
      exact ⟨steer ha (fun he=> (h3 he).elim) (fun hi=>steer hb (fun he=> (h2 he).elim)
                                     (fun _=> higher hg.1 hl.1 hl.2.1)),punct_up hg.2 hl.2.1⟩
    next e=>
      refine ⟨steer ha (fun _=>hh) (fun hA=>steer hb (fun _=>hh) ?_),punct0 (stable_home h.align).1 hl.2.2.1⟩
      intro hC
      have h1: d.tag i=0:=by by_contra he; apply e (hz.2 ⟨he,hC,hA⟩)
      rw [h1] at hg; exact higher hg.1 hl.1 hl.2.1

abbrev voteC(p:Cage)(c:ℕ):=16*(16*p.OutC c)
lemma shoots {u:Ballot d}(he:Style p s d θ c u)(i:ℕ)(b:Bool):
     let v:= valN p _ u b i
     (film s i 0).rite (voteC p c) (p.belt b) v ∧ Punct s.head (voteC p c) v:=by
    dsimp only
    let m:=p.OutC c
    let S:=film s i 0
    have hl:= (h.cost_vol true).2.2.1
    let q:=p.shaft b
    have hu : q.b.key S.head=i:=by simp [q,shaft,Branch.key,fellow,leftQ,S,film,info,panelx]
    have hz : Punct S.head m (q.N S):=by
       have he1:= lb_le_inc p.m
       change lb p.m +1 ≤ p.OutC c*s.d
       unfold OutC goodz; rw [h.hi]; omega
    have hA:= q.earns (rocks (h.goodF i 0)) hl (Game p d u b) hz (fun j hj=>by
         have hv:S.bench q.b j=film s j 0:=by
             simp [S,bench,film,q,shaft,fellow,Branch.port,panelx,stairs]
         rw [hv]; exact ⟨(he.serve j hj b).2,(he.serve j hj b).1⟩)
    dsimp only at hA
    rw [hu] at hA
    exact ⟨hA.2,punct_up hA.1 (by unfold voteC; omega)⟩

end Ink

namespace Style
variable {p s d θ c u}(h:Style p s d θ c u)
include h
omit h in
lemma markers {o T} (hx:p.Ink s d θ o c T)(b): Seek.part (Game p _ u b) p.m=
         (range d.n).filter (ColorF.hoot d u.wt b):=by
   unfold Seek.part; rw [hx.mp]; ext i; simp only [mem_filter]
   by_cases hp:ColorF.hoot d u.wt b i
   · have hs:d.tag i≠0:=hp.1
     unfold Game; rw [ite_eq_left hp]; simp only [hp]; tauto
   unfold Game; rw [ite_eq_right hp]; simp only [hp]; simp
lemma ck {o T} (hx:p.Ink s d θ o c T)(b):(Seek.part (Game p _ u b) p.m).card ≤ p.k:=by
    rw [(markers (u := u)) hx,← h.rightP]; exact hx.ok.amount0 h.legally (h.height.symm ▸ hx.ht0) b

abbrev child(p:Cage)(d:Depot)(u:Ballot d)(b:Bool)(i:ℕ):ℕ:=Relay.mark (valN p _ u b i)
def listed(p:Cage)(d:Depot)(u:Ballot d)(b:Bool)(i:ℕ):Prop:= valN p d u b i≠0
omit h in
lemma park {b i}(hi:listed p d u b i):
     let k:=child p _ u b i
     ColorF.hoot d u.wt b k ∧ valN p d u b i=Seek.bin k (Game p _ u b k)∧(Seek.part (Game p d u b) k).card=i:=by
    let v:=Game p d u b
    obtain ⟨j,hj,hr,hg⟩:= (Seek.casebook v i p.m).resolve_left hi
    have hs:child p d u b i=j:=by change Relay.mark ((Seek.relief v i p.m).2)=_; rw [hg]; simp [Seek.bin,Relay.mark]
    have hh:v j≠0:=(mem_filter.1 hj).2
    dsimp only; rw [hs]
    unfold v Game at hh; split at hh
    · exact ⟨by assumption,hg,hr⟩
    contradiction
lemma many {b i}(hi:listed p d u b i){T o}(hx:p.Ink s d θ o c T):i<p.k:=by
    have ht:= not_le.1 (mt Seek.missed.2 (show (Seek.relief (Game p _ u b) i p.m).2≠0 from hi))
    exact ht.trans_le (h.ck hx b)
omit h in
lemma hears {T o b i} (hx:p.Ink s d θ o c T)(he:ColorF.hoot d u.wt b i):∃ j,listed p d u b j∧child p d u b j=i:=by
    let v:=Game p d u b; let u0:=(Seek.part v i).card
    have ha : v i≠0:=by unfold v Game; rw [ite_eq_left he]; exact he.1
    have hg:valN p d u b u0=Seek.bin i (v i):=Seek.order ((hx.ok.card0 i he.1).trans_eq hx.mp) ha rfl
    refine ⟨u0,?_,?_⟩
    · unfold listed; rw [hg]; exact ne_of_gt (Seek.binpos ..)
    unfold child; rw [hg]; simp [Seek.bin,Relay.mark]
omit h in
lemma lonely {T o b i j}(hx:p.Ink s d θ o c T)
    (ht:listed p d u b i)(he:listed p d u b j)(hp:d.pos (child p d u b i)=d.pos (child p d u b j)): i=j:=by
   have ha:=(park (p := p) (d := d) (u := u)) ht; have hz:=(park (p := p) (d := d) (u := u)) he
   dsimp only at ha hz
   have hb:=hx.ok.uniq _ _ ha.1.1 hz.1.1 hp
   rw [hb,hz.2.2] at ha; exact ha.2.2.symm
end Style
end
end ExactDerandomization.Stem.Cage

end

section

namespace ExactDerandomization.Stem.Cage
open Counter Relay Rill Fret Reed Analysis Hie At Finset Seats Buf Lu Depot.Trust Ink
open Lyric
noncomputable section
open scoped Classical
variable (p:Cage) (s:Seats)(d:Depot)(θ:ℝ)(o:Bool→Trio)(c T:ℕ)
abbrev zbase (b:Bool):Lyric:= Lu.son 0 (p.root b)
abbrev rearmM(x:Word)(i:History):ℕ:= stairs true x (i.1,Relay.mark i.2)
lemma rearmK : Kn rearmM:= (stairK true).comp (Kn.first.tuple (((Kn.unpack (α:=History)).comp Kn.next).left))
abbrev fruit (b:Bool) :=let v:=campk p.kn
                         let q:=p.belt b
                         Cargo.choose q ((p.zbase b).choir v)
                           (Cargo.combine q ((p.figure b).choir v) ⟨_,rearmK⟩)
abbrev exitP (c:ℕ)(b:Bool):= (p.figure b).cost c
abbrev lastP (c:ℕ):= voteC p c+200+p.exitP c true+p.exitP c false
abbrev totalG(c:ℕ):=4*p.lastP c
abbrev skyG:=prepare p+(p.figure true).tail+(p.figure false).tail

abbrev spice (p:Cage)(d:Depot)(i:ℕ)(o:Bool→Trio)(b:Bool) (u:Ballot d):ℝ:=
    if valN p d u b i=0 then 0 else d.y.val d.S p.k (o b) (d.pos (Style.child p d u b i))

namespace Ink
variable {p s d θ o c T}(h:Ink p s d θ o c T)
include h
lemma spaceG: 1  ≤  voteC p c ∧ voteC p c ≤ p.lastP c ∧ p.lastP c  ≤ p.totalG c:=by
    have he:=(h.cost_vol true).2.2.1; unfold lastP totalG; unfold lastP voteC at *; omega
theorem fruitage {u:Ballot d}(hs:Style p s d θ c u)(i b) (H:ℕ)
   (hk:H+p.skyG*s.d ≤ T):
    (film s i 0).band (p.totalG c) H (p.root b) (p.fruit b) (spice p d i o b u):=by
   have ⟨hC,hD,hH⟩:=h.spaceG
   let q:=p.belt b; let j:=valN p d u b i; let C:= p.lastP c
   have hu:=h.shoots hs i b
   have hp:= h.goodF i 0
   have hj: (film s i 0).rite C q j:= higher hu.1 hC hD
   have hc:1 ≤  C:=hC.trans hD; have hm:1 ≤ c:=by have:=h.hc; omega
   have hA:H+(p.figure b).tail*s.d  ≤  T:=by
       have he:(p.figure b).tail  ≤  p.skyG:=by cases b <;> unfold skyG <;> omega
       exact (Nat.add_le_add_left (Nat.mul_le_mul_right s.d he) H).trans hk
   apply Seats.avis (higher hj hc hH)
   · intro hz
     unfold spice; rw [ite_eq_left hz]
     let f:=p.zbase b
     have hf: Chor (campk p.kn) c T (film s i 0) f 0:=by
        have ht:Lu.Standard (film s i 0) (campk p.kn) T:=⟨hp,spanFilm h.expire i 0⟩
        convert ht.shins c (p.root b) 0 (by simp) using 1; norm_num
     exact flex (sing hf hm (H:=H) (by have he:H  ≤  T:= (Nat.le_add_right ..).trans hA
                                       simpa only [f,zbase,tail,son,zero_mul,add_zero]))
             (Lyric.cost_hi hm) (by change powder 100  ≤  4*(p.lastP c); unfold lastP powder; omega) le_rfl
   intro hj0
   let a:=Style.child p d u b i
   have ht : Style.listed p d u b i:= hj0
   have hh:d.live a:=(Style.park ht).1.1
   have ha:berth ⟨_,rearmK⟩ (film s i 0) j= film s a 0:=by
       simp only [berth,j,a,film,info,panelx,Style.child,rearmM,stairs,Reed.V,dec_round,ite_true]
   apply advises (rocks hp) (punct_up hu.2 hD) hc hj
   rw [ha]
   unfold spice; rw [ite_eq_right hj0,←h.seats0 b]
   apply flex (sing (h.sculpt hh b) hm hA) (cost_hi hm) _ le_rfl
   change p.exitP c b  ≤  C; unfold C lastP; cases b <;> omega
end Ink

structure Harvest (u:Ballot d):Prop where
    style:Style p s d θ c u
    budget:1 ≤ p.totalG c
    stem :∀ i b, (film s i 0).rite (p.totalG c) (p.belt b) (valN p d u b i) ∧
                                       Punct s.head (p.totalG c) (valN p d u b i)
    song:∀ i b H,H+p.skyG*s.d  ≤  T→
                (film s i 0).band (p.totalG c) H (p.root b) (p.fruit b) (spice p d i o b u)

lemma bloom (h:Ink p s d θ o c T) (hp:p.skyG*s.d ≤ T):∃ u,Harvest p s d θ o c T u:=by
   obtain ⟨u,hv⟩:= h.chose (show _ from (Nat.mul_le_mul_right _ (show prepare p  ≤  p.skyG by unfold skyG; omega)).trans hp)
   obtain ⟨h1,h2,h3⟩:=h.spaceG
   exact ⟨u,hv,h1.trans (h2.trans h3),fun i b=>⟨higher (h.shoots hv i b).1 h1 (h2.trans h3),
            punct_up (h.shoots hv i b).2 (h2.trans h3)⟩,h.fruitage hv⟩

end
end ExactDerandomization.Stem.Cage

end

end OAI