lean/OAI/Computability/Logspace/RowEvaluation.lean

import OAI.Computability.Logspace.EstimatorMachine
import OAI.Computability.Logspace.EstimatorParameters
import OAI.Computability.Logspace.QueryCombinators

namespace OAI

/-!
Evaluation of row scores, ranks, and compressed numerical values.

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

set_option autoImplicit true

section

namespace ExactDerandomization.Cambria
open Analysis Hie Counter Relay Rill Fret Grain Net Est At Buf Stage Finset
open Chime Scheme Dome Cone.ConeX _root_.OAI.ExactDerandomization.Sub Swirl
open Helix Helix.Age Helix.Mold Helix.Orbit Helix.Foil Helix.Moon
open SiteX SiteX.Line Terrain Terrain.Bank Glass Glass.Rod Helix.Was
open Arena Fret.Seats Pier Arena.Flash
noncomputable section
open scoped Classical

abbrev Hull := (ℕ×ℕ×ℕ) × (History × Issue)
abbrev Helm := (ℕ×ℕ) × History × (ℕ×Arch)

abbrev Surf:=Hull×Helm
namespace Surf
abbrev mx (t:Surf):=t.1.1.1
abbrev days(t:Surf):=t.1.1.2
abbrev chartQ(t:Surf):=t.1.2.1
abbrev dye(t:Surf):=t.1.2.2
abbrev A (t:Surf):=t.2.1
abbrev U (t:Surf):=t.2.2.1
abbrev sunset (t:Surf):=t.2.2.2
abbrev windC (t:Surf)(y:ℕ) :ℕ:= t.sunset.2.1*y+t.sunset.2.2
abbrev priceC (t:Surf)(h:ℕ): Aide:= ((t.A.1,h-1),(decide (t.U.1≠0),t.U),t.sunset)
def green(t:Surf)(b:Bool)(n x:ℕ):Bool:=
    if b then Print.shoot n t.days.1 x t.dye.1 else Print.shoot n t.days.2 x t.dye.2.1
def heatC (t:Surf)(b:Bool)(n x:ℕ):Bool:=
    Print.touched b n t.days.1 t.days.2 x t.chartQ.1 t.chartQ.2 t.dye
def flareQ (t:Surf)(b:Bool)(n x:ℕ):Bool:= t.green b n x && t.heatC b n x
def frontC (t:Surf) (n x:ℕ):Bool := decide (x<t.mx) && t.flareQ true n x
def finalC (t:Surf)(n x:ℕ):Bool:= t.flareQ false n (t.windC x)

namespace Prep
variable {α}[Wire α]{n i:PT α ℕ}{s:PT α Surf}
lemma windK (hp:Kn s)(hr:Kn i):Kn (fun x a=> (s x a).windC (i x a)):=
    let p:= hp.right.right.right.right
    (p.left.times hr).add p.right
lemma headF (hn:Kn n)(hi:Kn i)(hs:Kn s) (b:Bool):Kn (fun x a=> (s x a).green b (n x a) (i x a)):=by
   have h:=hs.left.right.right; have hf:=hs.left.left.right
   cases b
   · exact Print.shootK hn hf.right hi h.right.left
   exact Print.shootK hn hf.left hi h.left
lemma chapter (hn:Kn n)(hi:Kn i)(hs:Kn s) (b:Bool):Kn (fun x a=> (s x a).flareQ b (n x a) (i x a)):=
    let h:=hs.left.left.right
    let q:=hs.left.right
    Print.both (headF hn hi hs b) (Print.touchedK b hn h.left h.right hi q.left.left q.left.right q.right)
lemma facet (hn:Kn n)(hi:Kn i)(hs:Kn s): Kn (fun x a=> (s x a).frontC (n x a) (i x a)):=
   Print.both (hi.lt hs.left.left.left) (chapter hn hi hs true)
lemma aideK (hs:Kn s) (hi:Kn i): Kn (fun x a=> (s x a).priceC (i x a)):=by
   have h:= hs.right.right.left; let k:= GK.decideK (GK.notG (GK.eqG h.left (Kn.fix 0)))
   exact (hs.right.left.left.tuple hi.pred).tuple ((k.tuple h).tuple hs.right.right.right)
end Prep
end Surf

abbrev PondQ:=Cub ℕ Surf
variable {q w h:ℕ}

namespace Hood
variable (r:Rock q w h)

abbrev codeE(x:Word)(t i j:ℕ):ℕ:= unitN r x (walkq (Scheme.inside t) j true i)
def spill (x:Word)(t i:ℕ):ℕ → ℕ
   | 0=>0
   | j+1=> if codeE r x t i j=0 then spill x t i j else j+1
lemma ankle {x:Word}{t i m:ℕ}:spill r x t i m  ≤  m:=by
    induction m with
    | zero=>rfl
    | succ m ih=> unfold spill; split;omega;rfl
variable {α}[Wire α]{i t:PT α ℕ}
lemma bloomK (he:Kn t)(hv:Kn i)(j):Kn (fun x a=>codeE r x (t x a) (i x a) j):=
    let k:= ((Kn.unpack (α:=History)).comp he).right
    (unitKN r).comp (((k.tuple (Kn.fix j)).tuple (Kn.fix _)).tuple hv)
lemma fledK (he:Kn t)(hv:Kn i)(j): Kn (fun x a=> spill r x (t x a) (i x a) j):=by
    induction j with
    | zero=> exact Kn.fix 0
    | succ j ih=> exact (bloomK r he hv j).cond_eq (Kn.fix 0) ih (Kn.fix _)

def saute (v:PondQ)(g:ℕ):Cog:=
   Arena.Flash.search ⟨_,fledK r (v.runs.comp Kn.first).right.left.left Kn.next g⟩

lemma codePos {x:Word}{t i j y:ℕ}:
   codeE r x (Was.atom t) i j=y+1↔Flight r x t j i y:=by
    have hg:= travel r x t j true i y
    unfold stopped at hg
    have hf: Scheme.inside (Was.atom t)=t:=by simp [Scheme.inside,Was.atom,hole]
    unfold codeE
    rw [hf, ← show (if unitN r x _=0 then none else some (unitN r x _-1))=some _↔Flight r x t j i y from hg]
    split <;> grind
lemma lastE {x:Word}{t i j m:ℕ}(hm:j < m):
   spill r x (Was.atom t) i m=j+1↔ ∃ y,Flight r x t j i y:=by
    induction m with
    | zero=>omega
    | succ m ih=>
      unfold spill
      cases he:codeE r x (Was.atom t) i m with
      | zero=>
        by_cases hi:j=m
        · simp only [ite_true]; have hp:=ankle r (x:=x) (m:=m) (t:=Was.atom t) (i:=i)
          refine iff_of_false (by omega) ?_
          rintro ⟨y,h⟩; have hc:=(codePos r).2 h; rw [hi,he] at hc; omega
        simpa only [ite_true] using ih (by omega)
      | succ y=>
        rw [ite_eq_right (by omega: y+1 ≠ 0)]
        have ha:=(codePos r).1 he
        refine ⟨fun e=>⟨y,(show j=m by omega) ▸ ha⟩,?_⟩
        rintro ⟨y',ht⟩
        have hp:=fly_pair r ha ht; omega
lemma dawn {x:Word}{t i m:ℕ}: spill r x (Was.atom t) i m=0↔∀ j < m,∀ y,¬ Flight r x t j i y:=by
   refine ⟨fun h j hj y he=>?_,fun h=>?_⟩
   · have ht:= (lastE r hj).2 ⟨y,he⟩; omega
   have hz:= ankle r (x:=x) (m:=m) (t:=Was.atom t) (i:=i)
   by_contra hc
   generalize he: spill r x (Was.atom t) i m=k at *
   cases k with
   | zero=> contradiction
   | succ k=> obtain ⟨y,hp⟩:= (lastE r (by omega)).1 he; exact h k (by omega) _ hp
end Hood

namespace Keel
open Surf

variable (r:Rock q w h)
def early (p:PondQ):Cog:=Flash.search
     ⟨_,Kn.wash.comp (Surf.Prep.facet (r.nKn) Kn.next (p.runs.comp Kn.first))⟩
def foilT (p:PondQ):Sight:=⟨_,p.runs.right.left.left⟩
def quarry (p:PondQ):Sight:=⟨_,p.runs.right.left.right⟩
def cream(x:ℕ):ℕ:= if x=0 then 0 else x+1
lemma creamK{α}[Wire α]{f:PT α ℕ}(h:Kn f):Kn (fun x a=>cream (f x a)):=
      h.cond_eq (Kn.fix 0) (Kn.fix 0) h.succ
def renew (f:Sight):Cog:=.seq (Dome.Bullet.snap f)
                  (etch (α:=ℕ) (fun _ a=>cream a.2) (creamK Kn.next))
abbrev Tor(g:Sight) : Flag:=⟨_,(g.runs.comp (tokenK.left.comp Kn.first)).eq (Kn.fix 0)⟩
def broom(p:PondQ) (m:ℕ) : Cog :=
    .bif (Tor (quarry p)) (Hood.saute r p m) (renew (quarry p))
def frontQ(p:PondQ)(m:ℕ): Cog:= demand (early r p) (broom r p m)

section
variable {u:Line (q:=q) (w:=w) (h:=h)}
variable (g:PondQ){t x s c:ℕ}
variable (he:u.D.Suite t)(hp:2 ≤ c)(hx:x∈u.D.P)
variable {q:Surf}(hf:g.f u.x s=q)
include he hp hx hf
lemma answer :
    (u.D.chord t x s).rite c (early u.r g) (enc (q.frontC u.n x)) := by
   refine found u.D he hx hp ?_ (seal_bit u.D he hp (q:=s) _)
   change enc ((g.f _ _).frontC u.n x)=_
   rw [show g.f u.D.x _=q from hf]
lemma tome {b:ℕ}(hk:q.A.2=0)
     (hr: StampX s (Hood.spill u.r u.x q.A.1 x b) u.D t c):
   (u.D.chord t x s).rite c (broom u.r g b) (Hood.spill u.r u.x q.A.1 x b):=by
    intro n hn
    apply Lot.Mane.yes _ ((found u.D he hx hp ?_ hr) _ hn)
    · change decide ((g.f u.x ((Scheme.token (postcard s 0)).1)).A.2=0)=true
      simp [token,postcard,hf,hk]
    change Hood.spill u.r u.x (g.f u.x s).A.1 x b=_
    rw [hf]
lemma summons {b m y z:ℕ}(hh:u.D.W b+u.D.D t ≤ u.D.W t) (hk:q.A.2=hole b m)
     (hv:u.D.swears (bell b m 0) x z)(hs:StampX s z u.D t c)(hr:StampX s (cream z) u.D t c)(hc:q.A.2 ≠ 0):
   (u.D.chord t x s).rite c (broom u.r g y) (cream z):=by
    intro n hn
    have hf' : (quarry g).f u.D.x s=hole b m:=
                          (congrArg (fun a:Surf=>a.A.2) hf).trans hk
    have hu:= Bullet.copy u.D he hp hx hh hf' hs hv n hn
    have hm := he.pit hx s _ hn
    refine Lot.Mane.no ?_ (.seq hu (etches _ _ (i:=z) rfl hu.spots.2 (plight hr hm (by omega))))
    change decide ((g.f u.x ((Scheme.token (postcard s 0)).1)).A.2=0)=false
    simp [token,postcard,hf,hc]
end
end Keel

end
end ExactDerandomization.Cambria

end

section

namespace ExactDerandomization.Cambria
open Analysis Hie Counter Relay Rill Fret Grain Net Est At Buf Stage Finset
open Chime Scheme Dome Cone.ConeX _root_.OAI.ExactDerandomization.Sub Swirl
open Helix Helix.Age Helix.Mold Helix.Orbit Helix.Foil Helix.Moon Helix.Torch
open SiteX SiteX.Line Terrain Terrain.Bank Glass Glass.Rod
open Arena Fret.Seats Pier Arena.Flash
noncomputable section
open scoped Classical
variable {q w h:ℕ}

namespace Mica
open Surf
variable (r:Rock q w h)
def cube (b:Bool) (q:Surf):NoteM :=
    let s:=enc q.dye
    (q.sunset.2,enc (if b then trail q.days.2 s else measureL q.days.1 q.days.2 q.chartQ.1 q.chartQ.2 s))
lemma cubeK {α}[Wire α]{p:PT α Surf}(h:Kn p)(b:Bool):Kn (fun x a=>cube b (p x a)):= by
    have he:=h.right.right.right.right
    have hp:=h.left.left.right
    have hv:=h.left.right
    have hm:=Kn.wash.comp hv.right
    cases b
    · exact he.tuple (Kn.wash.comp ((Kn.fix _).tuple (hp.tuple (hv.left.tuple hm))))
    exact he.tuple (Kn.wash.comp ((Kn.fix _).tuple (((Kn.fix _).tuple hp.right).tuple ((Kn.fix _).tuple hm))))
def giz (b:Bool)(q:PondQ):Cub ℕ (ℕ×ℕ×NoteM):=
    let h:=q.runs.right.right.left
    ⟨_,h.left.tuple (h.right.tuple (cubeK q.runs b))⟩
abbrev clue (q:PondQ)(b:Bool):Cog:= Bullet.snap (garnish (giz b q))
abbrev invite (q:PondQ):Cog:= demand (clue q true) (clue q false)
def leafC (g:PondQ):Cog:= by
    let h:=g.runs.comp (Kn.first (β:=ℕ))
    exact search ⟨_,Kn.wash.comp (Surf.Prep.chapter r.nKn (Surf.Prep.windK h Kn.next) h false)⟩
abbrev ole (g:PondQ):Sight:=⟨_,g.runs.right.right.left.left⟩
def moth (g:PondQ):Cog := Cog.bif (Keel.Tor (ole g)) (leafC r g) (invite g)
abbrev host (r:Rock q w h)(g:PondQ)(c:ℕ):Gate:= ⟨Keel.frontQ r g c,c,Keel.foilT g,moth r g⟩
section
variable {u:Line (q:=q) (w:=w) (h:=h)}
variable (g:PondQ)
variable (s:Surf)

structure LiftQ (u:Line (q:=q) (w:=w) (h:=h))(s:Surf)(a:ℕ)(y:ℕ):Prop where
     launch : y∈ u.D.P
     attr : s.windC y∈ u.D.P
     dual:u.D.dual s.sunset.1 0
     bond:u.D.W (cell s.sunset.1)+u.D.D a ≤ u.D.W a
     aims:u.D.curve s.sunset.1 0 true y=some (s.windC y)

abbrev Stars:= Option History
inductive Partner(u:Line (q:=q) (w:=w) (h:=h))(s:Surf)(a:ℕ)(x:ℕ):Stars → Prop
   | soil (h:s.U.1=0) (hg:LiftQ u s a x) : Partner u s a x (some (0,x))
   | leaf {f:Stars}(h:s.U.1≠0)
          (he:u.wick0.Veil u.torch s.U.1)
          (hq:∀ b,u.wick0.Ok (cube b s))
          (hp:u.D.W s.U.1+u.D.D a ≤ u.D.W a)
          (hd:u.D.D s.U.1  ≤ 2*u.D.D a)
          (ht:u.eye.Flora u.torch.p s.U.1 s.U.2 x f)
          (hl:∀ {i y},f=some (i,y)→LiftQ u s a y): Partner u s a x f
def census (s:Surf)(b:Bool)(n:ℕ)(e:Stars): Bool:=
    match e with
    | none=>false
    | some (_,y) => if b then s.green false n (s.windC y) else s.heatC false n (s.windC y)
def exitE (s:Surf)(n:ℕ)(e:Stars):Bool:= census s true n e && census s false n e
lemma exitJ (s:Surf)(n i j:ℕ):exitE s n (some (i,j))=s.finalC n j:=rfl

variable {g s a x c i}
lemma glow0 (b:Bool)(f:Pane){m:ℕ}(h:s.windC m∈ u.D.P):
      u.torch.lit u.D.x (cube b s) m f=(census s b u.n (some (0,m)),f):=by
    have he:s.windC m  ≤  u.n:=Nat.le_of_lt_succ (mem_range.1 h)
    have hr: ray0 (u.torch.port u.D.x) (cube b s).1 m=s.windC m:=min_eq_right he
    unfold Harp.lit; rw [hr]; cases b
    · change Helix.Torch.lamp u.r u.x ((_,_),f)=_
      simp [lamp,ray,cube,census,Surf.heatC,measureL]
    · change Helix.Torch.lamp u.r u.x ((_,_),f)=_
      simp [Helix.Torch.lamp,Helix.Torch.ray,cube,census,Surf.green,trail]
lemma theEnd (hr:u.D.Suite a)(hx:x∈u.D.P)(hf:g.f u.x i=s)(hv:2 ≤ c){f:Stars}
     (hz:Partner u s a x f):
  (u.D.chord a x i).rite c (moth u.r g) (enc (exitE s u.n f)):=by
   cases hz with
   | soil h hg=>
     intro n hn
     refine Lot.Mane.yes ?_ ((found u.D hr hx hv ?_
                          (seal_bit u.D hr hv (q:=i) (exitE s u.n (some (0,x))))) n hn)
     · change decide ((g.f u.x ((token (postcard i 0)).1)).U.1=0)=true
       simp only [token,postcard,dec_round,hf,h]; rfl
     change enc ((g.f u.x i).finalC u.n x)=_
     rw [hf]; rfl
   | @leaf f hm he hq hp hd ht hl=>
     have hh (b:Bool):(u.D.chord a x i).rite c (clue g b) (enc (census s b u.n f)):=by
        let c0:=s.U
        have hk:(giz b g).f u.x i=(c0.1,c0.2,cube b s):=
             congrArg (fun x:Surf=> (x.U.1,x.U.2,cube b x)) hf
        apply Arena.Flash.maskB hr hx hv hp he hk (hq b) ht
        cases f
        · rfl
        next p=> rcases p with ⟨j,y⟩
                 intro p h
                 exact glow0 b p (hl (show some (j,y)=some (j,y) from rfl)).attr
     have hu: (u.D.chord a x i).rite c (invite g) (enc (exitE s u.n f)):=by
        rw [exitE,← Arena.Flash.brilliant]
        apply wanted u.D hr hx hv _ _ (hh true); exact fun _=>hh false
     intro n hn
     refine Lot.Mane.no ?_ (hu n hn)
     change decide ((g.f u.x ((token (postcard i 0)).1)).U.1=0)=false
     simp only [token,postcard,dec_round,hf]; simp [hm]
end
end Mica
end
end ExactDerandomization.Cambria

end

section

namespace ExactDerandomization.Cambria
open Analysis Hie Counter Relay Rill Fret Grain Net Est At Buf Stage Finset
open Chime Scheme Dome Cone.ConeX _root_.OAI.ExactDerandomization.Sub Swirl
open Helix Helix.Age Helix.Mold Helix.Orbit Helix.Foil Helix.Moon Helix.Torch
open SiteX SiteX.Line Terrain Terrain.Bank Glass Glass.Rod
open Arena Fret.Seats Pier Arena.Flash Surf Mica
noncomputable section
open scoped Classical
variable {q w h:ℕ}

namespace BadgeX
def iris : Stars → ℕ
    | none=>0
    | some z=>z.1
def portM : Stars → ℕ
    | none=>0
    | some z=>z.1+1
def pointE:Stars → ℕ
    | none=>0
    | some z=>z.2
def collect (t:Surf)(n x:ℕ)(g:Stars)(m:ℕ → Stars):Stars:=
    if t.frontC n x then match g with
    | none=>none
    | some (k,i)=>match m i with
                  | none=>none
                  | some (_,j)=> if t.finalC n j then some (k+1,t.windC j) else none
    else none
lemma iris_le (t:Surf)(n x g m): iris (collect t n x g m) ≤ portM g:=by
    unfold collect
    split; grind [iris,portM]
    cases g <;> simp [iris,portM]
lemma spark {t:Surf}{n x w z g m}(h:collect t n x g m=some (w,z)):
     t.frontC n x=true ∧ ∃ a i b j,g=some (a,i) ∧m i=some (b,j) ∧
                                                w=a+1∧ z=t.windC j∧ t.finalC n j=true:=by
    unfold collect at h
    split at h <;> try contradiction
    rename_i hc
    refine ⟨hc,?_⟩
    cases g <;> try contradiction
    next v=> rcases v with ⟨a,i⟩
             cases he:m i with
             | none=> simp only [he,reduceCtorEq] at h
             | some q=> rcases q with ⟨b,j⟩
                        simp only [he] at h
                        split at h
                        · next hv=> simp only [Option.some.injEq,Prod.mk.injEq] at h; exact ⟨_,_,_,_,rfl,he,h.1.symm,h.2.symm,hv⟩
                        contradiction

variable {u: SiteX.Line (q:=q) (w:=w) (h:=h)}

structure Crew(u:Line (q:=q) (w:=w) (h:=h)) where
    cage :CageQ
    g:PondQ
    t:Surf
    info:ℕ
    c:ℕ
    bound:ℕ
    x:ℕ
    entrance:Stars
    exit0:ℕ → Stars
namespace Crew
variable (p:Crew u)
abbrev outR := collect p.t u.n p.x p.entrance p.exit0
abbrev src := p.cage.dataN
abbrev skill (x:ℕ):=u.D.chord p.src x p.info
abbrev stationP :=p.skill p.x
abbrev host0:= host u.r p.g p.bound
abbrev lampQ := p.t.frontC u.n p.x
structure Good (p:Crew u):Prop where
    pro:p.cage.Front u
    chart:u.Chart
    capcost : 4 ≤ p.c
    ix:p.x ∈ u.D.P
    fiat:p.g.f u.x p.info=p.t
    capw : ∀ i:ℕ,i ≤ p.bound→StampX p.info i u.D p.src p.c
    caps : ∀ i:ℕ,i ≤ p.bound→u.smallQ p.cage.visN i

abbrev hitP (p:Crew u)(k:ℕ):Prop:=Liaison u.D p.x p.cage.dataN p.t.A.1 k
structure Arrived(p:Crew u) :Prop where
    stable:p.Good
    next : p.lampQ=true →
          portM p.entrance ≤ p.bound ∧ p.stationP.rite p.c (Keel.broom u.r p.g p.bound) (portM p.entrance)
    tours :∀ k i,p.lampQ=true→p.entrance=some (k,i)→p.hitP k∧u.D.curve p.t.A.1 k true p.x=some i∧
                                            Partner u p.t p.src i (p.exit0 i)

namespace Arrived
variable {p:Crew u}(hp:p.Arrived)
include hp
lemma throng : p.host0.Crest u.D p.src p.info p.c p.x
                                 (if p.lampQ then portM p.entrance else 0):=by
   let i:=portM p.entrance
   have hb:(if p.lampQ then i else 0) ≤ p.bound:=by
      split
      · next hv=> exact (hp.next hv).1
      omega
   have hs:= hp.stable
   have hg:= hs.chart.rent hs.pro.pos; have hk:=hs.capcost
   refine ⟨?_,hb,hg,hs.ix,by omega,hs.capw _ hb⟩
   have hf: win (enc p.lampQ) i=(if p.lampQ then i else 0):=by cases he:p.lampQ<;>rfl
   rw [← hf]
   apply Flash.wanted u.D hg hs.ix (by omega) (enc p.lampQ) i
           (Keel.answer _ hg (by omega) hs.ix hs.fiat)
   intro h
   exact (hp.next (by cases ht:p.lampQ; rw [ht] at h; exact False.elim (h rfl); rfl)).2

lemma wreath :
   iris p.outR ≤ p.bound ∧ p.stationP.rite p.c (p.host0.garden u.D.s) (iris p.outR):=by
    have hh:=hp.throng
    by_cases hz:p.lampQ=true
    · rw [ite_eq_left hz] at hh
      refine ⟨le_trans (iris_le ..) (hp.next hz).1,?_⟩
      cases h:p.entrance with
      | none=>
        rw [h] at hh
        change p.stationP.rite p.c _ (iris (collect _ _ _ _ _))
        rw [collect.eq_def,ite_eq_left hz,h]; exact hh.asleep
      | some s=>
        obtain ⟨k,i⟩:=s
        rw [h] at hh
        obtain ⟨he,hz0,h1⟩:=hp.tours k i hz h
        have hx:=(he.ready.swaps k he.holds p.x he.xem true i hz0).1
        have hr :portM (some (k,i))-1=k:=by simp [portM]
        have hg: win (enc (exitE p.t u.n (p.exit0 i))) (portM (some (k,i)))=iris p.outR:=by
             unfold outR collect
             rw [ite_eq_left hz,h]
             dsimp only
             cases ht:p.exit0 i with
             | none => rfl
             | some r=>
                obtain ⟨w,v⟩:=r
                rw [exitJ p.t]
                cases hn:p.t.finalC u.n v <;> simp only [hn,Bool.false_eq_true,ite_true,ite_false] <;> rfl
        have hs:= hp.stable; have hb:=hs.capcost
        rw [← hg]
        apply hh.morning (by simp [portM]) (t:=p.t.A.1) _ (hr ▸ he) (hr ▸hz0)
             (Mica.theEnd (hs.chart.rent hs.pro.pos) hx hs.fiat (by omega) h1)
        exact congrArg (fun a:Surf=>a.A.1) hs.fiat
    rw [ite_eq_right hz] at hh
    unfold outR collect; rw [ite_eq_right hz]; exact ⟨Nat.zero_le _,hh.asleep⟩

lemma paths {i:ℕ} (he:u.smallQ p.src i)
    (hv:u.D.swears (post p.src p.cage.tagop i 0) p.x (iris p.outR))
    (hr:offer u.s.pave u.x (stem p.cage.visN i (iris p.outR))=p.t.priceC (iris p.outR)):
   u.eye.Flora u.torch.p p.cage.visN i p.x p.outR :=by
    let N:=p.cage.visN; let z:=u.eye; let q:=u.torch.p
    have hb:=hp.stable; have hs:= hb.pro
    have hx:=hs.point0 hb.chart i (hs.back0 he)
    have hh: u.D.echo (u.eye.ear u.torch.p N i) p.x=iris p.outR:=by
             rw [show u.eye.ear u.torch.p N i = _ from hs.ear0 i]; exact u.D.identity hv
    cases hg:p.outR with
    | none=> apply Flora.abs; rw [hg] at hh; exact ⟨hx,hb.ix,hh⟩
    | some r=>
      obtain ⟨k,j⟩:=r
      obtain ⟨hm,a,w,b,y,hg0,hf0,rfl,rfl,ht⟩:= spark hg
      apply Flora.wet
      obtain ⟨ha,hi,hF⟩:= hp.tours _ _ hm hg0
      rw [hf0] at hF
      have H: a+1 ≤ p.bound:=by have h:=(hp.next hm).1; rw [hg0] at h; exact h
      let K:=a+1; let c:=p.t
      have hU : z.h0 q N i K=c.A.1 ∧ z.ip q N i K=a ∧ z.f0 q N i K=c.sunset.1 ∧
           z.b1 q N i K=decide (c.U.1 ≠0) ∧ z.s1 q N i K=c.U.1 ∧ z.i1 q N i K=c.U.2 ∧
                                                q.shift.f z.D.x (stem N i K)=c.sunset.2:=by
        let E:=offer u.s.pave u.x (stem N i K)
        have he:E=c.priceC K:=by rw [hg] at hr; exact hr
        change E.1.1=_∧E.1.2=a∧E.2.2.1=_∧E.2.1.1=_∧E.2.1.2.1=_∧E.2.1.2.2=_∧E.2.2.2=_
        simp [he,K,priceC]
      obtain ⟨h1,h2,h3,h4,h5,h6,h7⟩:=hU
      have hh0 (hl:LiftQ u c p.src y):z.Point q N i K p.x w y (c.windC y):=by
         have hs':u.D.D N=u.D.D p.src:=hs.grain.symm
         have hS:=hs.price
         have HD:i=i:=rfl
         have hpost(v)(hr:u.D.W (cell v)+u.D.D p.src ≤ u.D.W p.src):u.D.W (cell v)+z.n N ≤ u.D.W N:=
              le_trans (by rw [show z.n N=u.D.D p.src from hs']; exact hr)
                 ((Nat.le_add_right (u.D.W p.src) _).trans hS)
         have he:N=N:=rfl
         refine ⟨hx,Nat.succ_ne_zero _,?_,hb.caps _ H,?_,?_,?_,hb.ix,
             (ha.ready.swaps a ha.holds _ ha.xem _ _ hi).1,hl.launch,hl.attr,?_,?_,?_⟩
         · rw [hg] at hh; exact hh
         · rw [h2]; exact hb.caps _ (by omega)
         · rw [h1,h2]; exact ⟨ha.holds,hpost _ ha.pays⟩
         · rw [h3]; exact ⟨hl.dual,hpost _ hl.bond⟩
         · rw [h1,h2]; exact hi
         · rw [h3]; exact hl.aims
         rw [h7]; exact min_eq_right (show c.windC y ≤ u.n from Nat.le_of_lt_succ (mem_range.1 hl.attr))
      cases hF with
      | soil hz hL=> exact Pond.leaf (hh0 hL) (by rw [h4,show c.U.1=0 from hz]; rfl)
      | leaf hC he hq ho hd hh hr=>
         cases hh with
         | wet ht=>
             refine Pond.born (hh0 (hr rfl)) ?_ ?_ ?_ (h':=b) ?_
             · rw [h4]; simp [show c.U.1≠0 from hC]
             · rw [h5, show z.n N = u.D.D p.src from hs.grain.symm]
               exact ho.trans ((Nat.le_add_right _ _).trans hs.price)
             · rw [h5, show z.n N = u.D.D p.src from hs.grain.symm]; exact hd
             · rw [h5,h6]; exact ht
end Arrived
end Crew
end BadgeX

end
end ExactDerandomization.Cambria

end

section

namespace ExactDerandomization.Cambria
open Analysis Hie Counter Relay Rill Fret Grain Net Est At Buf Stage Finset
open Chime Scheme Dome Cone.ConeX _root_.OAI.ExactDerandomization.Sub Swirl
open Helix Helix.Age Helix.Mold Helix.Orbit Helix.Foil Helix.Moon Helix.Torch
open SiteX SiteX.Line Terrain Terrain.Bank Glass Glass.Rod
open Arena Fret.Seats Pier Arena.Flash Surf Mica BadgeX
noncomputable section
open scoped Classical
variable {q w h:ℕ}

namespace Era

variable {u:Line (q:=q) (w:=w) (h:=h)}
def budget (r:Rock q w h):ℕ:=bootC r+1
def tariff (r:Rock q w h):ℕ:=budget r+powder 100+Bullet.roomS+16
lemma billed (r:Rock q w h): 4≤ tariff r∧Bullet.roomS  ≤ tariff r∧powder 100  ≤  tariff r:=by
    unfold tariff; omega
lemma educated (p:Crew u) {v:MintV}(hB:Bank.Turf v u.r u.v)
   (h:p.cage.Front u)(he:u.Chart)(hb:p.bound=budget u.r)(hc:tariff u.r ≤ p.c)
   (hu:p.x∈u.D.P)(hg:p.g.f u.x p.info=p.t):p.Good:=by
      have hM:= (he.rent h.pos).well.1
      refine ⟨h,he,(billed _).1.trans hc,hu,hg,fun i hv=>?_,fun i hv=>?_⟩
      · have hz:= lb_le_inc i
        have hs:i+2 ≤  p.c:=by rw [hb] at hv; unfold tariff at hc; omega
        unfold StampX Punct; change lb i+1 ≤ p.c*u.D.D p.cage.dataN
        nlinarith
      have hs: i+1 ≤ Bank.hx v u.r:=by rw [hb] at hv; unfold Bank.hx Bank.hu hi; unfold budget at hv; omega
      have hl:= lb_le_inc i
      have ht: i+1 ≤ u.eye.e:=hs.trans hB.cost0
      rw [h.grain] at hM; change lb i ≤ u.eye.e*u.D.D p.cage.visN; nlinarith
lemma orn {g:Surf}{v x:ℕ}(h:u.Chart)(hk:u.D.W 0+u.D.D v ≤ u.D.W v)(hx:x∈u.D.P)
     (hp:g.sunset=(Was.atom 0,1,0)): LiftQ u g v x :=by
   have hs:g.windC x=x:=by simp [windC,hp]
   have he:x ≤ u.n:=Nat.le_of_lt_succ (mem_range.1 hx)
   refine ⟨hx,hs.symm ▸ hx,?_,?_,?_⟩
   · rw [hp]; exact (Line.Chart.voteRoot (u := u)) (Nat.zero_le _) (Nat.zero_le _)
   · rw [hp]; exact (show u.D.W (cell (Was.atom 0))+_≤_ from by
                                   rw [show cell (Was.atom 0)=0 from by simp [cell,Was.atom,hole]]; exact hk)
   rw [hs,hp]
   exact h.basic0 (show Was.Flight u.r u.x 0 0 x x by simp [Was.Flight,he]) (Nat.zero_le _) (Nat.zero_le _)
lemma oust {g:Surf}{v x i:ℕ}(h:u.Chart){p:MintV}(hB:Turf p u.r u.v)
     (hk:u.D.W 0+u.D.D v ≤ u.D.W v)(hx:x∈u.D.P)
     (hi:i<u.w0.p.M) (hp:g.sunset=(Was.atom (3+i),u.w0.p.M,i))
     (hf:radix u.w0.p.M x i∈u.D.P):
   LiftQ u g v x:=by
   let y:= radix u.w0.p.M x i
   have hs:g.windC x=y:=by simp [radix,y,windC,hp,Nat.add_comm]
   have he:x ≤ u.n:=Nat.le_of_lt_succ (mem_range.1 hx)
   have hy:y ≤ u.n:=Nat.le_of_lt_succ (mem_range.1 hf)
   have hv:3+i ≤ u.v.bonus:= (show 3+i  ≤  bootC u.r by unfold bootC; change i < u.r.w.p.M at hi;omega).trans hB.coinbook
   refine ⟨hx,hs.symm ▸ hf,?_,?_,?_⟩
   · rw [hp]; exact (Line.Chart.voteRoot (u := u)) hv (Nat.zero_le _)
   · rw [hp]; exact (show u.D.W (cell (Was.atom (3+i)))+_≤_ from by
                                   rw [show cell (Was.atom (3+i))=0 from by simp [cell,Was.atom,hole]]; exact hk)
   rw [hp]
   apply h.basic0 _ hv (Nat.zero_le _)
   have hq:¬(3+i=1∨3+i=2):=by omega
   have ht:=Nat.ne_of_gt (show 0<3+i by omega)
   have hL:3+i-3=i:=by omega
   rw [hs]
   simp only [Was.Flight,hq,ht,hL,ite_false,he,hy,show i<u.r.w.p.M from hi, ite_true]; refine ⟨?_,?_,?_,?_⟩ <;> first|rfl|trivial

structure Spell (s:Surf) (u:Line (q:=q) (w:=w) (h:=h)) :Prop where
     a : s.days.1 ≤ roof u.r u.x
     b : s.days.2 ≤ roof u.r u.x
     c0 : s.chartQ.1 ≤ u.r.w.ell*Moon.M u.r u.x
     c1:s.chartQ.2 ≤ 2^(planets u.r u.x*u.v.e)
     d : enc s.dye  ≤ WaresCap u.r u.x
     t : s.sunset.2.1  ≤ u.n∧s.sunset.2.2 ≤ u.n
lemma overly {s:Surf}(h:Spell s u)(b:Bool) :u.wick0.Ok (cube b s):=by
   refine ⟨?_,h.t⟩
   cases b
   · exact Helix.Torch.housed u.r u.v u.x (by decide: (5:ℕ) ≤ 16) h.a h.b h.c0 h.c1 h.d
   exact Helix.Torch.housed u.r u.v u.x (by decide: (4:ℕ) ≤ 16)
                           (Nat.zero_le _) h.b (Nat.zero_le _) (Nat.zero_le _) h.d

open Was

lemma basePort {p:Crew u}(h:p.Good) {i:ℕ}(ha:p.t.A=(Was.atom i,0))
   (hh:u.D.W 0+u.D.D p.src ≤ u.D.W p.src)(hb:i ≤ u.v.bonus)(hr:p.bound ≤ u.v.bonus+1)
   (hf:∀ k j,p.lampQ=true→ (p.entrance=some (k,j)↔ k<p.bound∧Flight u.r u.x i k p.x j))
   (hv:∀ k j,p.lampQ=true→ p.entrance=some (k,j)→ Partner u p.t p.src j (p.exit0 j)):
   p.Arrived:=by
     have h1:p.t.A.1=atom i:=by rw [ha]
     have h2:p.t.A.2=0:=by rw [ha]
     let m:= Hood.spill u.r u.x p.t.A.1 p.x p.bound
     refine ⟨h, fun e=>?_,fun k j e hz=>?_⟩
     · have hx:m=portM p.entrance:=by
           unfold m; rw [h1]
           cases hh:p.entrance with
           | none=> exact (Hood.dawn _).2 fun j hj v he=>by have hp:=(hf j v e).2 ⟨hj,he⟩; simp [hp] at hh
           | some s=>
             rcases s with ⟨k,b⟩
             obtain ⟨he,hp⟩:=(hf _ _ e).1 hh
             exact (Hood.lastE u.r he).2 ⟨b,hp⟩
       rw [←hx]; have ht:m ≤ p.bound:=Hood.ankle u.r
       exact ⟨ht,Keel.tome p.g (h.chart.rent h.pro.pos) ((by omega:2 ≤ 4).trans h.capcost) h.ix h.fiat h2 (h.capw m ht)⟩
     obtain ⟨ht,hp⟩:=(hf _ _ e).1 hz
     have hk:k ≤ u.v.bonus:=by omega
     refine ⟨?_,?_,hv k j e hz⟩
     · unfold Crew.hitP; rw [h1]
       exact ⟨by rw [show cell (atom i)=0 from by simp [cell,atom,hole]]; exact hh,
              h.ix,(Line.Chart.voteRoot (u := u)) hb hk,(h.chart.bootsBasic _).canonicalS⟩
     rw [h1]; exact h.chart.basic0 hp hb hk

lemma echoPort {p:Crew u} {w:Fabric u}{f:Producer}{s:MintV}(h:p.Good) (h0:w.Efine s f)
    (hg:w.govern=true){i:ℕ}(hi:i<w.Rslots)
    (he:p.t.A=(w.slotWord i,hole w.leaveE.dataN (hole 0 i)))
    (hA:u.D.W w.leaveE.dataN+u.D.D p.src ≤ u.D.W p.src)
    (hW:u.D.W (w.c 12 0)+u.D.D p.src ≤  u.D.W p.src)
    (hk:clim u.w0.p+1  ≤  p.bound)
    (hh:∀ k j,p.lampQ=true → (p.entrance=some (k,j) ↔ k≠0 ∧ f.tag p.x i=k∧ f.locate p.x i=j))
    (hv:∀ k j,p.lampQ=true→ p.entrance=some (k,j)→ Partner u p.t p.src j (p.exit0 j)):
    p.Arrived:=by
    have h1:p.t.A.1=w.slotWord i:=by rw [he]
    have h2:p.t.A.2=hole w.leaveE.dataN (hole 0 i):=by rw [he]
    have h3:w.leaveE.tagop=0:=rfl
    let K:=f.tag p.x i
    refine ⟨h, fun e=>?_,fun k j e hz=>?_⟩
    · have hm:=h0.sector.suit
      have hf:K  ≤  clim u.w0.p:=by
          by_cases hl:K=0; rw [hl]; omega
          exact h0.tin hg _ _ hl
      have hX:portM p.entrance=Keel.cream K:=by
         cases hq:p.entrance with
         | none=> have hj :K=0:=by by_contra hc; have hp:= (hh K (f.locate p.x i) e).2 ⟨hc,rfl,rfl⟩; simp [hp] at hq
                  unfold Keel.cream; rw [hj]; rfl
         | some r=>obtain ⟨k,j⟩:=r; obtain ⟨hv,hw,_⟩:=(hh _ _ e).1 hq; unfold Keel.cream K; rw [hw,ite_eq_right hv]; rfl
      rw [hX]
      have hu:Keel.cream K ≤ p.bound:=by unfold Keel.cream; split<;>omega
      refine ⟨hu,Keel.summons p.g (h.chart.rent h.pro.pos) ((by omega:2 ≤ 4).trans h.capcost)
                h.ix h.fiat hA h2 ?_ (h.capw K (by omega)) (h.capw _ hu) ?_⟩
      · exact (hm.trace p.x h.ix).next i (hm.coil.awake (hm.coil.size0 _ hi))
      rw [h2]; exact ne_of_gt (Fret.Seek.binpos w.leaveE.dataN _)
    obtain ⟨hl,hk0,hj⟩:= (hh k j e).1 hz
    have hy:k ≤ clim u.w0.p:=by rw [← hk0]; exact h0.tin hg _ _ (by show f.tag _ _≠0; rw [hk0]; exact hl)
    obtain ⟨he,hq,hx⟩:=h0.source hg i hi k (Nat.pos_of_ne_zero hl) hy
    refine ⟨?_,?_,hv k j e hz⟩
    · unfold Crew.hitP; rw [h1]
      exact ⟨by rw [show cell (w.slotWord i)=w.c 12 0 from by simp [Fabric.slotWord,cell,hole]]; exact hW,
                             h.ix,he,hq⟩
    rw [h1,hx p.x h.ix,ite_eq_left hk0,hj]

end Era
end
end ExactDerandomization.Cambria

end

section

namespace ExactDerandomization.Cambria
open Analysis Hie Counter Relay Rill Fret Grain Net Est At Buf Stage Finset
open Chime Scheme Dome Cone.ConeX _root_.OAI.ExactDerandomization.Sub Swirl
open Helix Helix.Age Helix.Mold Helix.Orbit Helix.Foil Helix.Moon Helix.Torch
open SiteX SiteX.Line Terrain Terrain.Bank Glass Glass.Rod
open Arena Fret.Seats Pier Arena.Flash Surf Mica BadgeX
open Fret.Lyric Reed.Lu Arena.Song Arena.Amber
noncomputable section
open scoped Classical
variable {q w h:ℕ}

namespace Wear

abbrev Rus:= (ℕ × Bool) × Coin × ℕ × History × ℕ
abbrev GridY:=ℕ×Surf×Rus
abbrev allQ : Cub ℕ GridY:=⟨_,Kn.unpack⟩
abbrev skyG:PondQ:=⟨_,allQ.runs.right.left⟩
abbrev rx:Cub ℕ Rus:=⟨_,allQ.runs.right.right⟩
def shelf(k:Knob):Knob:=
   let p(a:Cub ℕ ℕ):Cub ℕ ℕ:= ⟨_,a.runs.comp allQ.runs.left⟩
   ⟨p k.height,p k.bank,p k.store⟩
def tin : Tear := Amber.first0 ⟨_,rx.runs.right.left⟩
abbrev pin1 : Sight:= ⟨_,rx.runs.right.right.left⟩
abbrev pin2:Kiwi:=⟨_,rx.runs.right.right.right.left⟩
abbrev packC:Sight:=⟨_,rx.runs.right.right.right.right⟩
def tone (old:Bool) (o:ℕ):Sight:=
     let H:=rx.runs.right.right.right.left
     if old then ⟨_,Kn.wash.comp (H.left.tuple (Kn.fix (hole o 0)))⟩ else
                 ⟨_,Kn.wash.comp (H.left.tuple (Kn.wash.comp ((Kn.fix o).tuple H.right)))⟩
def pitch (p:Crt)(i:ℕ):Crt:=
     let q:= Age.styx p
     let s:Scout:=(q.1,q.2.1,i,q.2.2.2)
     (p.1,p.2.1,s,Age.env p)
abbrev rate0(u:Crt)(b:ℕ):ℕ:= hole (enc (pitch u b)) (hole 1 0)
def prefixD (b:ℕ):Sight:=
     let p:= (Kn.unpack (α:=Crt)).comp packC.runs
     let q:=p.right.right.left
     let s:= q.left.tuple (q.right.left.tuple ((Kn.fix b).tuple q.right.right.right))
     let t:=p.left.tuple (p.right.left.tuple (s.tuple p.right.right.right))
     ⟨_,Kn.wash.comp ((Kn.wash.comp t).tuple (Kn.fix (α:=ℕ) (hole 1 0)))⟩

lemma prefD(a i x): (prefixD a).f x i=rate0 (dec (packC.f x i)) a:=rfl

abbrev Health (p:MintV): Coin:=Coin.ofZ (2^p.coin)
abbrev range0 (p:MintV):= (2:ℝ)^p.coin
def powerF (p:MintV):Tear:= syrup (Health p)
def falls (p:Sight) :Cub ℕ Bool:=⟨_,p.runs.eq (Kn.fix 0)⟩

abbrev visitAt (p:ℕ):Kiwi:= Flash.clan (Keel.foilT skyG) (p-1)
def spreadC (f:Sight)(k:Knob)(c:Coin): Cog:=
    Song.pleas (falls f) (choir k (.solo 0 ⟨_,Kn.fix c⟩)) (Bullet.snap f)
def dose (k:Knob)(p:MintV): Lyric:= Amber.shade (spreadC pin1 k (Coin.inv (Health p))) p.coin (powerF p)
def puff (i n:ℕ)(k:Knob)(s:Scheme):Lyric:=
    let f:Sight:=prefixD n
    let e:Lyric:= .solo 0 ⟨_,Kn.fix (Coin.ofZ 1)⟩
    .use 0 (Pier.escort s (visitAt i) (Song.pleas (falls packC) (choir k e) (Bullet.snap f)))
def nook (i:ℕ)(k:Knob)(s:Scheme):ℕ → Lyric
   | 0=>zeroE
   | j+1=> Reed.Lu.sup (nook i k s j) (puff i j k s)
def gemini (i:ℕ)(k:Knob)(s:Scheme)(p:MintV)(T:ℕ):Lyric:=
    let h:= times (Amber.moonF tin p.prism) (dose k p)
    let v:= Amber.blossoms (visitAt i) s (Wear.tone false 1) p.coin (powerF p)
    times (times h v) (boostR (nook i k s T))

abbrev markR(r:Rock q w h)(i:ℕ): Tear:= by
    let k:= (skyG.runs.right.left.left).comp (Kn.first (β:=ℕ))
    have ht:= Was.edgeK r Kn.next (Hood.bloomK r k Kn.next (i-1)).pred
    exact ⟨_,Coin.ofK ht.ZofN⟩
abbrev moss (p:MintV) (i:ℕ)(r:Rock q w h) :Lyric :=
       times (Amber.moonF tin p.prism) (Amber.moonF (markR r i) 2)
abbrev past (k:Knob) (p:MintV) (f:Sight):Lyric:=
    Amber.petal f (2*p.sealR) (awry k (2*p.sealR))
def bia (b:Bool)(p:MintV)(k:Knob):Lyric:=
   let l:= past k p (Wear.tone false (if b then 1 else 2))
   if b then diff l (past k p (Wear.tone true 5)) else l

abbrev shapeC (k:ℕ): Cub ℕ Bool:=⟨_,rx.runs.left.left.eq (Kn.fix k)⟩
abbrev sourceB (b:Bool) : Cub ℕ Bool:= by
   let h:=rx.runs.left.right
   cases b
   · exact ⟨_,h.cond (Kn.fix false) (Kn.fix true)⟩
   exact ⟨_,h⟩

/-- mask kind2 and kind1 use lit-only pricing. -/
def coast (p:MintV)(c:Knob)(r:Rock q w h)(s:Scheme)(b:Bool)(i:ℕ):Cog:=
    let t:= p.inputH
    let v:= Song.pleas (shapeC 1) (roost c (moss p i r) t) (roost c (gemini i c s p r.w.p.T) t)
    let e:= snow c t
    if i=0 then e else Song.pleas (shapeC 0) (roost c (bia b p c) t)
                                  (Song.pleas (sourceB b) v e)
def hub (r:Rock q w h):Gate:= Mica.host r skyG (Era.budget r)
abbrev grainq (p:MintV)(k:Knob)(r:Rock q w h)(s:Scheme)(b:Bool):Cog:=
     (hub r).openE s (coast p k r s b)

namespace Paper
def same (x y : Lyric):Prop:= x.weight=y.weight∧ x.tail=y.tail ∧ ∀ c, Lyric.cost x c=Lyric.cost y c
lemma oneself (x:Lyric): same x x:=⟨rfl,rfl,fun _=>rfl⟩
lemma use (f g:Cog) (i:ℕ):same (.use i f) (.use i g):=⟨rfl,rfl,fun _=>rfl⟩
lemma everF {i:ℕ}{x y:Cub CoinQuery Coin}:same (.solo i x) (.solo i y):=⟨rfl,rfl,fun _=>rfl⟩
namespace same
lemma stronger {x y m n:Lyric}(h:same x y)(e:same m n)(v:Doop)(b:ℕ):same (.duet v x m b) (.duet v y n b):=by
   obtain ⟨_,_,_⟩:=h; obtain ⟨_,_,_⟩:=e
   simp_all [same,Lyric.weight,Lyric.cost,Lyric.tail]
lemma plies {x y m n:Lyric}(h:same x y)(e:same m n)(v:Doop):same (bi v x m) (bi v y n):=by
   unfold bi; rw [h.1,e.1]; exact h.stronger e v _
lemma score0 {x y}(h:same x y):same (Song.sQ x) (Song.sQ y):=
     (oneself _).plies ((oneself _).plies h _) _
lemma txt {x y}(h:same x y):same (takeF x) (takeF y):=
     let e:= ((oneself _).plies h Doop.prod).score0
     (e.plies e _).plies (e.plies e _) _
lemma rosebud {x y}(h:same x y):same (faded x) (faded y):=
    (h.txt.plies ((oneself _).plies ((oneself _).plies h Doop.minus).txt _) _).plies (oneself _) _
lemma red {x y}(h:same x y):same (boostR x) (boostR y):=
     (((oneself _).plies h Doop.prod).plies (oneself _) Doop.minus).rosebud
lemma stow {x y}(h:same x y)(i):same (reset x i) (reset y i):= h.stronger (oneself _) _ _
end same
lemma reed (i j k q s p u):same (Wear.nook i k s u) (Wear.nook j q p u):=by
   induction u with
   | zero=> exact oneself _
   | succ u ih=> exact ih.plies (use _ _ _) _
lemma reedX (i j k q s p M c):same (gemini i k s M c) (gemini j q p M c):=
     (((oneself _).plies ((use _ _ _).plies (oneself _) _) _).plies
             ((use _ _ _).plies (oneself _) _) _).plies (reed ..).red _
lemma biaS (p k s) (b:Bool):same (bia b p k) (bia b p s):= by
   have h (v:Sight):same (past k p v) (past s p v):= (use _ _ _).plies everF _
   cases b
   · exact h _
   exact (h _).plies (h _) _
lemma backS (v:MintV)(r:Rock q w h)(i j):same (moss v i r) (moss v j r):=
       (oneself _).plies everF _

abbrev noneT : Tags:=⟨0,0,0,0,0,0⟩
def money0 (p:MintV)(f:Lyric)(c:ℕ):ℕ:=
   let r:=reset f p.inputH
   Lyric.cost r c+ Lyric.tail r
def budgetD (p:MintV)(r:Rock q w h):ℕ:=
   let k:=knob r noneT
   let s:= schedule r noneT
   let c:=Era.tariff r
   let v(f):= money0 p f c
   c+v (bia true p k)+v (bia false p k)+v (gemini 1 k s p r.w.p.T)+v (moss p 1 r)
lemma eras (p:MintV)(r:Rock q w h) (s:Scheme) (k:Knob) (b:Bool) (i:ℕ):
   Era.tariff r ≤ budgetD p r ∧ ∀ f, f=bia b p k∨ f=gemini i k s p r.w.p.T∨f=moss p i r →
       (reset f p.inputH).cost (Era.tariff r) ≤ budgetD p r ∧
          (reset f p.inputH).tail ≤ budgetD p r:=by
    let c:= Era.tariff r
    let t:=p.inputH
    have hh {f g:Lyric}(h:same f g)(he:money0 p f c ≤ budgetD p r):
        Lyric.cost (reset g t) c ≤ budgetD p r ∧ Lyric.tail (reset g t) ≤ budgetD p r:=by
       have hg:=same.stow h t; unfold money0 at he; unfold t at *; obtain ⟨-,hz,hz2⟩:=hg
       dsimp only at he; rw [hz,hz2] at he; omega
    refine ⟨?_,fun g h=>?_⟩
    · unfold budgetD; dsimp only; omega
    rcases h with rfl|rfl|rfl
    · apply hh (biaS p (knob r noneT) k b)
      cases b <;> unfold budgetD c <;> dsimp only <;> omega
    · apply hh (reedX 1 i (knob r noneT) _ (schedule r noneT) _ p _)
      unfold budgetD c; dsimp only; omega
    apply hh (backS p r 1 _); unfold budgetD c; dsimp only; omega
end Paper
end Wear
end
end ExactDerandomization.Cambria

end

section

namespace ExactDerandomization.Cambria
open Analysis Hie Counter Relay Rill Fret Grain Net Est At Buf Stage Finset
open Chime Scheme Dome Cone.ConeX _root_.OAI.ExactDerandomization.Sub Swirl
open Helix Helix.Age Helix.Mold Helix.Orbit Helix.Foil Helix.Moon Helix.Torch
open SiteX SiteX.Line Terrain Terrain.Bank Glass Glass.Rod
open Arena Fret.Seats Pier Arena.Flash Surf Mica BadgeX
open Fret.Lyric Reed.Lu Arena.Song Arena.Amber Wear Wear.Paper
noncomputable section
open scoped Classical
variable {q w h:ℕ}

namespace Rime
structure Nest(u:Line (q:=q) (w:=w) (h:=h)) where
    snow0: Crew u
    diploma:Rus
    tune:MintV

namespace Nest
variable {u:Line (q:=q) (w:=w) (h:=h)}
variable (s:Nest u)
abbrev ray:=s.snow0
abbrev krod (u:Line (q:=q) (w:=w) (h:=h)):=shelf (knob u.r u.v)
abbrev a:=s.ray.src
abbrev v:=s.ray.info
abbrev t:=s.tune
abbrev H:=u.D.high s.a
abbrev T:=s.H+budgetD s.t u.r*u.D.D s.a
abbrev home:=s.ray.stationP
abbrev whereF(x:ℕ):=s.ray.skill x
abbrev beaming := Chor (krod u) (Era.tariff u.r) s.T s.home
abbrev optic := s.diploma.1
abbrev addr1:= s.diploma.2.2.1
abbrev addr2:= s.diploma.2.2.2.1
abbrev capV:=s.diploma.2.2.2.2
abbrev cut := s.diploma.2.1
def addr3(o:ℕ):ℕ:=hole s.addr2.1 (hole o s.addr2.2)
def catshot(i:ℕ):ℕ:= rate0 (dec s.capV) i
structure Good (s:Nest u):Prop where
    grip:s.ray.Arrived
    matches0:s.ray.g=skyG
    earning:s.ray.c=Era.tariff u.r
    scores:s.v=enc ((s.ray.src,s.ray.t,s.diploma):GridY)
    arch:s.ray.bound=Era.budget u.r
    large0:budgetD s.t u.r ≤ u.v.slope

/-- score service at another location.W-clock sufficient. power j normalizer. -/
def VoiceS(x y j:ℕ)(A:ℝ): Prop := ∃ b m,
    y=hole b m∧ u.D.W b+u.D.D s.a ≤ u.D.W s.a∧
                 u.D.Voice b x m (u.D.high b) j A
def Loom0 (x y:ℝ) := min x y

structure Etude (s:Nest u)(k i:ℕ):Prop where
    low:Liaison u.D s.ray.x s.a s.ray.t.A.1 k
    yoke:u.D.curve s.ray.t.A.1 k true s.ray.x=some i

namespace Good
variable {s:Nest u} (hp:s.Good)
include hp
lemma primary : u.D.Suite s.a :=
     hp.grip.stable.chart.rent hp.grip.stable.pro.pos

set_option maxRecDepth 6000 in
lemma nested {x:ℕ} (he:x∈u.D.P): Align ((s.whereF x).head) (krod u) ∧
                                           Standard (s.whereF x) (krod u) s.T:=by
    have hx:= hp.primary
    have hT:= Studio.positioned (u:=u) hx he 0 0
    have hf: (s.whereF x).stable (krod u):=by
        intro j hj
        have H:= Mold.knows u.r u.v u.x u.prog s.a x (of_decide_eq_true hx.stage) he
                                  hp.primary.shape.price
        have hm:=H j hj
        have hh : (dec s.v:GridY).1=s.a:=by rw [hp.scores,dec_round]
        refine ⟨hm.1,?_,?_⟩
        · change (knob u.r u.v).height.f u.x (dec s.v:GridY).1=_
          rw [hh]; exact hm.2.1
        change (knob u.r u.v).bank.f u.x (dec s.v:GridY).1=_
        rw [hh]; exact hm.2.2
    refine ⟨stable_home hf,hf,?_⟩
    change 2^s.T ≤ 2^u.D.H
    apply Nat.pow_le_pow_right (by omega)
    exact Studio.stayedC hx le_rfl hp.large0
lemma born0 :Standard s.home (krod u) s.T:= (hp.nested hp.grip.stable.ix).2
lemma press {b:ℕ}(h:u.D.W b+u.D.D s.a ≤ u.D.W s.a):s.T ≤ u.D.high b:=Studio.soonerC hp.primary h hp.large0 le_rfl
lemma ru : rx.f u.x s.v=s.diploma :=by
    rw [hp.scores]; change (dec (enc _) : GridY).2.2=_
    rw [Wire.eq]
lemma shade0 : skyG.f u.x s.v=s.ray.t :=by rw [hp.scores]; change (dec (enc _) : GridY).2.1=_; rw [Wire.eq]
lemma visE0(k): (visitAt (k+1)).f u.x s.v=(s.ray.t.A.1,k):=by
      change ((skyG.f u.x s.v).A.1,k+1-1)=_
      rw [hp.shade0]; simp

lemma sell0 {f:Sight}{x j y}{A:ℝ} (hr:s.VoiceS x y j A)(he:f.f u.x s.v=y)(hx:x∈u.D.P):
    (s.whereF x).band (Era.tariff u.r) s.T 0 (Bullet.snap f) (A/(2:ℝ)^j):=by
   obtain ⟨b,m,hv,hb,hR⟩:=hr
   exact Amber.normalizeF hp.primary f (Era.billed ..).2.1 hx (he.trans hv) hb hR (hp.press hb)

omit hp in
lemma keep0 (_ b:Bool) : provided (sourceB b)=provided (sourceB b):=rfl
lemma scales : range0 s.t ≤ massB s.t.coin s.home.d:= by
    unfold massB
    apply pow_le_pow_right₀ (by norm_num)
    have hx:1 ≤ s.home.d:= hp.primary.well.1; nlinarith
omit hp in
lemma trueL : ((powerF s.t).f u.x (s.v,s.ray.x)).v=range0 s.t:=by simp [powerF,syrup,Health,range0]
lemma scrys (v:Coin){x i:ℕ}(he:x∈u.D.P)(hb:|v.v|  ≤  massB i (u.D.D s.a)):
   (s.whereF x).band (Era.tariff u.r) s.T i (choir (krod u) (.solo i ⟨_,Kn.fix v⟩)) v.v:=by
    have h:= (hp.nested he).2
    have hx:Chor (krod u) 1 s.T (s.whereF x) (.solo i ⟨_,Kn.fix v⟩) v.v:= .played h.st h.he (fun _ _=>rfl) hb
    exact flex (sing hx (by omega) (by simp [tail]))
           (cost_hi (p:=.solo i ⟨_,Kn.fix v⟩) (by omega :1 ≤ 1)) (Era.billed u.r).2.2 le_rfl
lemma barre {V:ℝ}(he:s.addr1 ≠ 0→s.VoiceS s.ray.x s.addr1 s.t.coin V) (hy:s.addr1=0 → V=1):
   s.beaming (dose (krod u) s.t) V :=by
    apply Amber.cast hp.born0 (j:=s.t.coin) ?_ (trueL (s := s)) hp.scales
    have hf: pin1.f s.home.l.x s.home.info=s.addr1:=congrArg (fun a:Rus=> a.2.2.1) hp.ru
    by_cases ht:s.addr1=0
    · apply Song.pinTrue (falls pin1) _
      · rw [hy ht]
        let g:=Coin.inv (Health s.t); have hh:g.v=1/(2:ℝ)^s.t.coin:=by simp [g,Health]
        have hb:|g.v| ≤ massB 0 s.home.d:=by
            rw [hh,abs_of_pos (by positivity)]; unfold massB
            simp only [Nat.zero_mul,pow_zero]
            apply (div_le_one (by positivity)).2; exact one_le_pow₀ (by norm_num)
        rw [←hh]; exact hp.scrys g hp.grip.stable.ix hb
      change decide (pin1.f s.home.l.x s.home.info=0)=true
      rw [hf];simp [ht]
    apply Song.pinFalse (falls pin1) _ (hp.sell0 (he ht) hf hp.grip.stable.ix)
    change decide (pin1.f s.home.l.x s.home.info =0)=false
    rw [hf];simp [ht]
lemma salve {k m:ℕ}(e:s.Etude k m){f:Sight}{j y}{A:ℝ} (hr:s.VoiceS m y j A)(he:f.f u.x s.v=y):
   s.home.band (Era.tariff u.r) s.T 0 (Pier.escort u.D.s (visitAt (k+1)) (Bullet.snap f)) (A/(2:ℝ)^j):=by
    have hm:2 ≤ Era.tariff u.r:= ((by omega: 2 ≤ 4).trans (Era.billed _).1)
    exact Pier.bowls hp.primary hm e.low (Era.billed _).2.1 (hp.visE0 k) e.yoke _
                                 (hp.sell0 hr he (Pier.street e.low e.yoke).xem)
lemma waltz {k m:ℕ}(e:s.Etude k m){A:ℝ} (hr:s.VoiceS m (s.addr3 1) s.t.coin A):
    s.beaming (Amber.blossoms (visitAt (k+1)) u.D.s (Wear.tone false 1) s.t.coin (powerF s.t)) A:=
   Amber.cast hp.born0 (hp.salve e hr (congrArg (fun a:Rus=>hole a.2.2.2.1.1 (hole 1 a.2.2.2.1.2)) hp.ru))
                                              (trueL (s := s)) hp.scales

set_option maxHeartbeats 1200000 in
lemma upso {i k m:ℕ}(e:s.Etude k m){A:ℝ} (hr:s.capV≠0→s.VoiceS m (s.catshot i) 0 A)(hy:s.capV=0→A=1) :
    s.beaming (puff (k+1) i (krod u) u.D.s) A:=by
    have hm:2 ≤ Era.tariff u.r:= ((by omega:2 ≤ 4).trans (Era.billed _).1)
    have hg:= (hp.nested (Pier.street e.low e.yoke).xem)
    refine Chor.byear (Pier.bowls hp.primary hm e.low (Era.billed _).2.1 (hp.visE0 k) e.yoke _ ?_)
    have hf: packC.f ((s.whereF m).l.x) (s.whereF m).info=s.capV:=congrArg (fun a:Rus=> a.2.2.2.2) hp.ru
    by_cases hz:s.capV=0
    · apply Song.pinTrue (falls packC) _
      · rw [hy hz]
        have hh : (Coin.ofZ 1).v=1:=by simp
        rw [←hh]; apply hp.scrys _ (Pier.street e.low e.yoke).xem
        simp [massB]
      change decide (packC.f ((s.whereF m).l.x) (s.whereF m).info=0)=true
      rw [hf];simp [hz]
    apply Song.pinFalse (falls packC) _
    · have hp0 : (prefixD i).f u.x s.v=s.catshot i:=
           by rw [prefD]; change rate0 (dec (packC.f ((s.whereF m).l.x) (s.whereF m).info)) i=_; rw [hf]; rfl
      simpa only [pow_zero,div_one] using hp.sell0 (hr hz) hp0 (Pier.street e.low e.yoke).xem
    change decide (packC.f ((s.whereF m).l.x) (s.whereF m).info=0)=false
    rw [hf];simp [hz]

def maxs (t:ℕ → ℝ):ℕ → ℝ
    | 0=>0
    | i+1=> max (maxs t i) (t i)
lemma carmen {k m:ℕ}(e:s.Etude k m) (A:ℕ → ℝ)(d:ℕ)
    (hx:∀ i<d,s.capV≠0→s.VoiceS m (s.catshot i) 0 (A i))(hl:s.capV=0→∀ i<d,A i=1):
   s.beaming (Wear.nook (k+1) (krod u) u.D.s d) (maxs A d):=by
    induction d with
    | zero=> exact hp.born0.sil
    | succ d ih=> exact hp.born0.up0 (ih (fun i h=>hx i (by omega)) (fun k i h=>hl k i (by omega)))
                        (hp.upso e (hx _ (by omega)) (fun h=>hl h d (by omega)))

omit hp in
lemma tensorB (b:Bool){_:ℕ}(hk:b=true):b=true:=hk
lemma warm (hs:|s.cut.v| ≤ massB s.t.prism (u.D.D s.a)):
     s.beaming (moonF tin s.t.prism) s.cut.v:=
    Amber.occlude hp.born0 _ _ (congrArg (fun a:Rus=>(a.2.1:Coin).v) hp.ru) hs
lemma salutation {k m:ℕ}(e:s.Etude k m)(A:ℕ → ℝ)(x y:ℝ)
    (hs:|s.cut.v| ≤ massB s.t.prism (u.D.D s.a))
    (he:s.addr1≠0→s.VoiceS s.ray.x s.addr1 s.t.coin x)(hy:s.addr1=0→x=1)
    (hr:s.VoiceS m (s.addr3 1) s.t.coin y)
    (hx:∀ i<u.w0.p.T,s.capV≠0→s.VoiceS m (s.catshot i) 0 (A i))(hl:s.capV=0→∀ i<u.w0.p.T,A i=1):
   s.beaming (gemini (k+1) (krod u) u.D.s s.t u.w0.p.T)
                    (s.cut.v*x*y*boost (maxs A u.w0.p.T)) :=
    hp.born0.mult0 (hp.born0.mult0 (hp.born0.mult0 (hp.warm hs) (hp.barre he hy)) (hp.waltz e hr))
                  (Song.Paint.boosted hp.born0 (hp.carmen e A _ hx hl))

lemma lecture {k i m:ℕ}(he:s.ray.t.A.1=Was.atom i)(hA:Was.Flight u.r u.x i k s.ray.x m)
    (hs:|s.cut.v| ≤ massB s.t.prism (u.D.D s.a)):
   s.beaming (moss s.t (k+1) u.r) (s.cut.v*(u.r.P.edge u.x s.ray.x m:ℝ)):=by
   let q:=u.r.P.edge u.x s.ray.x m
   have hz:q ≤ 2:=by unfold q Base.Source.edge; grind
   apply hp.born0.mult0 (hp.warm hs)
   apply occlude hp.born0
   · let g:= (skyG.f u.x s.v).A.1
     change (Coin.ofZ (u.r.P.edge u.x s.ray.x (_-1):ℤ)).v=_
     simp only [Coin.ofv,Int.cast_natCast]
     congr 2
     rw [show Hood.codeE u.r ..=m+1 from ?_]; omega
     change Hood.codeE u.r u.x (skyG.f u.x s.v).A.1 s.ray.x (k+1-1)=m+1
     rw [show skyG.f u.x s.v=s.ray.t from hp.shade0,he,show k+1-1=k from by omega]
     exact (Hood.codePos u.r).2 hA
   · change |(q:ℝ)|  ≤ _
     rw [abs_of_nonneg (by positivity)]
     exact le_trans (by exact_mod_cast hz) (swellB hp.primary.well.1).le
end Good
end Nest
end Rime
end
end ExactDerandomization.Cambria

end

section

namespace ExactDerandomization.Cambria.Rime.Nest
open Analysis Hie Counter Relay Rill Fret Grain Net Est At Buf Stage Finset
open Chime Scheme Dome Cone.ConeX _root_.OAI.ExactDerandomization.Sub Swirl
open Helix Helix.Age Helix.Mold Helix.Orbit Helix.Foil Helix.Moon Helix.Torch
open SiteX SiteX.Line Terrain Terrain.Bank Glass Glass.Rod
open Arena Fret.Seats Pier Arena.Flash Surf Mica BadgeX
open Fret.Lyric Reed.Lu Arena.Song Arena.Amber Wear Wear.Paper
noncomputable section
open scoped Classical
variable {q w h:ℕ}
variable {u:Line (q:=q) (w:=w) (h:=h)}
variable {s:Nest u}
namespace Good
variable (hp:s.Good)
include hp

lemma valueOld {A:ℝ}{f:Sight}{y}
   (hr:s.VoiceS s.ray.x y (2*s.t.sealR*u.D.D s.a) A)
   (he:f.f u.x s.v=y): s.beaming (past (krod u) s.t f) A:=
   Amber.cast hp.born0 (hp.sell0 hr he hp.grip.stable.ix)
       (Amber.scalingF (x:=s.ray.x) (q:=s.v) (hp.nested hp.grip.stable.ix).1 _) le_rfl

lemma biast (A:Pt)(y:ℝ)(b:Bool)
   (hr:∀ b:Bool,s.VoiceS s.ray.x (s.addr3 (if b then 1 else 2)) (2*s.t.sealR*u.D.D s.a) (Reed.sideq A b))
   (he:s.VoiceS s.ray.x (hole s.addr2.1 (hole 5 0)) (2*s.t.sealR*u.D.D s.a) y):
   s.beaming (bia b s.t (krod u)) (Reed.sideq (A-line y) b):=by
    have hp1(b):s.beaming (past (krod u) s.t (Wear.tone false (if b then 1 else 2))) (Reed.sideq A b):=
        hp.valueOld (hr b) (congrArg (fun (a:Rus)=>hole a.2.2.2.1.1 (hole (if b then 1 else 2) a.2.2.2.1.2)) hp.ru)
    have hp2:s.beaming (past (krod u) s.t (Wear.tone true 5)) y:=
        hp.valueOld he (congrArg (fun a:Rus=>hole a.2.2.2.1.1 (hole 5 0)) hp.ru)
    cases b
    · change s.beaming _ (A.2-0)
      rw [sub_zero]; exact hp1 false
    exact hp.born0.dubs (hp1 true) hp2
lemma knows0:hub u.r=s.ray.host0:=by
    unfold Crew.host0 hub; rw [hp.matches0,hp.arch]

abbrev C0 (s:Nest u):=budgetD s.t u.r
abbrev title (s:Nest u):=iris s.ray.outR
abbrev capsum (s:Nest u)(v:ℝ):= |v| ≤ massB s.t.inputH (u.D.D s.a)
abbrev sailed(s:Nest u)(f:Cog)(X:ℝ):=
     s.home.band (C0 s) s.H s.t.inputH f X
abbrev holding(s:Nest u)(b:Bool)(X:ℝ):=
     sailed s (coast s.t (krod u) u.r u.D.s b (title s)) X
abbrev gross(s:Nest u)(b:Bool)(X:ℝ):=
    sailed s (grainq s.t (krod u) u.r u.D.s b) X

lemma home0: s.home.rite (C0 s) ((hub u.r).garden u.D.s) (title s):=by
    rw [hp.knows0]
    have he:=hp.grip.wreath.2; rw [hp.earning] at he
    exact higher he (le_trans (by omega) (Era.billed ..).1)
              (eras s.t u.r u.D.s (krod u) true (title s)).1
lemma inoculates(b:Bool)(X:ℝ) (h:holding s b X):gross s b X:=
    Iris.parcel (by rw [hp.knows0]; exact hp.grip.wreath.1)
                                hp.home0 h
lemma lame : sailed s (snow (krod u) s.t.inputH) 0:=by
    have ht:= steam (krod u) s.t.inputH hp.born0 (Era.billed u.r).2.2
    have hz :1 ≤ Era.tariff u.r := by have := (Era.billed u.r).1; omega
    apply flex ht hz (eras s.t u.r u.D.s (krod u) true (title s)).1; unfold Nest.T; omega

lemma zen0(b:ℕ): (shapeC b).f s.home.l.x s.home.info=decide (s.optic.1=b):=
     congrArg (fun a:Rus=> decide (a.1.1=b)) hp.ru
lemma help0(b:Bool): (sourceB b).f s.home.l.x s.home.info=decide (s.optic.2=b):=by
   have he:s.diploma.1.2=s.optic.2:=rfl
   cases b
   · change (if (rx.f u.x s.v).1.2 then false else true)=_
     rw [hp.ru,he]; cases s.optic.2 <;> rfl
   change (rx.f u.x s.v).1.2=_
   rw [hp.ru,he]; cases s.optic.2 <;> rfl
lemma stellar (b:Bool)(X:ℝ){f:Lyric}
     (h:f=bia b s.t (krod u)∨ f=gemini (title s) (krod u) u.D.s s.t u.r.w.p.T∨f=moss s.t (title s) u.r)
     (hu:s.beaming f X)(he:capsum s X):
     sailed s (roost (krod u) f s.t.inputH) X:=by
   obtain ⟨hr,hs⟩:=(eras s.t u.r u.D.s (krod u) b (title s)).2 f h
   apply Amber.onQ _ _ _ hp.born0 hu (by have :=(Era.billed u.r);omega) _ hr he
   exact Nat.add_le_add_left (Nat.mul_le_mul_right _ hs) _

lemma torn (hx:title s=0)(b:Bool): gross s b 0:=by
   apply hp.inoculates; unfold holding coast
   dsimp only; rw [ite_eq_left hx]; exact hp.lame
lemma partOld {b X}(hr:title s≠0)(hs:s.optic.1=0)(ht:s.beaming (bia b s.t (krod u)) X)
    (he:capsum s X): gross s b X:=by
   apply hp.inoculates b X
   unfold holding coast; dsimp only; rw [ite_eq_right hr]
   apply Song.pinTrue _ _ (hp.stellar b X (Or.inl rfl) ht he)
   rw [hp.zen0,hs]; rfl

lemma youngNo {b}(hr:title s≠0)(hs:s.optic.1≠0)(ht:s.optic.2≠b):
    gross s b 0:=by
   apply hp.inoculates b 0
   unfold holding coast; dsimp only; rw [ite_eq_right hr]
   refine Song.pinFalse _ ?_ (Song.pinFalse _ ?_ hp.lame)
   · rw [hp.zen0]; simp [hs]
   rw [hp.help0]; simp [ht]
lemma youngYes {b X}(hr:title s≠0)(hs:s.optic.1≠0)(ht:s.optic.2=b)
    (hT : s.optic.1=1 → s.beaming (moss s.t (title s) u.r) X)
    (hA : s.optic.1≠1 → s.beaming (gemini (title s) (krod u) u.D.s s.t u.r.w.p.T) X)
    (he:capsum s X): gross s b X:=by
   apply hp.inoculates b X
   unfold holding coast; dsimp only; rw [ite_eq_right hr]
   refine Song.pinFalse (shapeC 0) (by rw [hp.zen0]; simp [hs]) (Song.pinTrue (sourceB b) (by rw [hp.help0];simp [ht]) ?_)
   · by_cases hv:s.optic.1=1
     · apply Song.pinTrue _ _ (hp.stellar b X (Or.inr (Or.inr rfl)) (hT hv) he)
       rw [hp.zen0]; simp [hv]
     apply Song.pinFalse _ _ (hp.stellar b X (Or.inr (Or.inl rfl)) (hA hv) he)
     rw [hp.zen0]; simp [hv]
omit hp in
lemma shekel {x:ℝ}{p:MintV}(h:Green u.r p)(ht:p=s.t) (he:|x| ≤  massB p.prism (u.D.D s.a)):
   capsum s x:= by
   subst p
   have hr:=h.honest
   exact he.trans (mass_mono (by unfold MintV.tokenH at hr; unfold MintV.inputH; omega) _)
end Good
end
end ExactDerandomization.Cambria.Rime.Nest

end

end OAI