| import OAI.Computability.Logspace.EstimatorInterfaces |
|
|
| namespace OAI |
|
|
| /-! |
| Finite query combinators and transparent Bernoulli operations. |
|
|
| From OpenAI, *Exact Derandomization of Logarithmic Space: L = RL = BPL*. |
| -/ |
|
|
| set_option autoImplicit true |
|
|
| section |
|
|
| namespace ExactDerandomization.Arena |
| open Counter Relay Rill Glass Fret Mint Swirl Finset Chime Scheme Glass.Rod |
| open Fret.Seats Chime.Dome |
|
|
| /-! Small combinators on Dome requests. All queries renormalized to |
| a local "info" origin. External typing covers any wind. -/ |
|
|
| abbrev Sight:=Cub ℕ ℕ |
| abbrev Kiwi:=Cub ℕ History |
|
|
| namespace Pier |
| noncomputable section |
|
|
| variable (p:Dome) |
| variable {u q x y c z t:ℕ} |
| abbrev StampX (x:ℕ)(h:ℕ)(r:Dome)(u c:ℕ):= Fret.Punct (r.chord u 0 x).head c h |
| lemma seal0 (he:p.Suite u)(hi:2 ≤ c):StampX q 0 p u c:= by |
| have hs:=he.well.1 |
| nlinarith |
| lemma seal1 (he:p.Suite u)(hi:2 ≤ c) :StampX q 1 p u c:= by |
| have hs:=he.well.1 |
| nlinarith |
| lemma seal_bit (he:p.Suite u)(hi:2 ≤ c) (b:Bool):StampX q (enc b) p u c:=by |
| cases b |
| · exact seal0 p he hi |
| exact seal1 p he hi |
| lemma seal_mark {H:ℕ}{w:Tape}{V:ℝ}(he:p.Suite u)(hi:Dome.Bullet.roomS ≤ c) |
| (hv:Checked w V H){t:ℕ}(hh:t ≤ H): StampX q (enc (dsign w t)) p u c:=by |
| have hr:= lb_mono (slate_le _ (safe_d hv hh)) |
| unfold StampX Fret.Punct |
| unfold Dome.Bullet.roomS at hi |
|
|
| /-- A reserved opaque motion |
| (motion called only at address clock=0 |
| strip their shot clock while keeping bounded record). -/ |
| structure Liaison (x:ℕ) (u:ℕ)(t i:ℕ) : Prop where |
| pays: p.W (cell t)+p.D u ≤ p.W u |
| xem:x∈p.P |
| holds:p.dual t i |
| ready:p.Streams t (p.curve t) |
|
|
| def onyx (f:Kiwi) (s:Scheme)(b:Bool)(x:Word)(a:Slip):ℕ:= |
| s.before b x (f.f x (Scheme.token a.1).1) |
| lemma onyxK(f:Kiwi)(s:Scheme)(b):Kn (onyx f s b):= |
| (s.beforeK b).comp (f.runs.comp (tokenK.left.comp Kn.first)) |
| def walk (s:Scheme)(f:Kiwi)(b:Bool)(m:Bool):Cog := |
| .toss ⟨_,onyxK f s b⟩ (if m then ⟨_,Kn.next⟩ else ⟨_,Kn.first.right.tuple Kn.next.right⟩) |
|
|
| section |
| variable {p:Dome} {u i x y t q z c:ℕ}{f:Kiwi} |
| (hu:p.Suite u)(hc:2 ≤ c)(he:Liaison p x u t i) |
| include hu hc he |
|
|
| lemma shares (b:Bool)(a:Pane)(hp:p.r.proper a)(hs:f.f p.x q=(t,i)): |
| ((p.chord u x q).seat (glove a x)).comp 0 c (walk p.s f b true) (0,glove a x) |
| (AtM (p.curve t i b x) a x):= by |
| let P:=fun x=> (p.chord u x q).seat (glove a x) |
| have hz (x:ℕ)(h:x∈p.P):(P x).OK:=hu.pit h q _ ⟨a,hp,rfl⟩ |
| have hy := hu.pull_shot he.pays x 0 q (seal0 p hu hc (q:=q)) (by omega:1 ≤ c) ((p.s.loc b).f p.x (t,i)) |
| refine Lot.Mane.toss (q':=p.pulseQ t i b) (a':=AtM (p.curve t i b x) a x) ?_ rfl |
| (plight (p:=P x) (seal0 p hu hc (q:=q)) (hz _ he.xem) (by omega)) |
| ?_ hy (he.ready.runs i he.holds x he.xem b a hp) |
| · change onyx f p.s b p.x (postcard q 0,0)=_ |
| unfold onyx |
| cases hh:p.curve t i b x with |
| | none=> exact plight (p:=P x) (seal0 p hu hc (q:=q)) (hz _ he.xem) (by omega) |
| | some v=> exact plight (p:=P v) (seal1 p hu hc (q:=q)) (hz _ (he.ready.swaps i he.holds x he.xem b v hh).1) (by omega) |
|
|
| lemma stroll {j n:ℕ}(hr:StampX q n p u c) (b:Bool)(a:Pane)(hp:p.r.proper a) |
| (hs:f.f p.x q=(t,i)) (hz:p.curve t i b x=some y): |
| ((p.chord u x q).seat (glove a x)).comp j c (walk p.s f b false) (n,glove a x) (n,glove a y):= by |
| let P:=fun x=>(p.chord u x q).seat (glove a x) |
| have hl(x:ℕ)(h:x∈p.P):(P x).OK:=hu.pit h q _ ⟨a,hp,rfl⟩ |
| have hy:=he.ready.swaps i he.holds x he.xem b y hz |
| refine Lot.Mane.toss (q':=p.pulseQ t i b) (a':=(1,glove a y)) ?_ rfl |
| (plight (p:=P x) hr (hl _ he.xem) (by omega)) (plight (p:=P y) hr (hl _ hy.1) (by omega)) ?_ ?_ |
| · change onyx f p.s b p.x (postcard q j,n)=_ |
| unfold onyx |
| · have hx:=hu.pull_shot he.pays x 0 q hr (by omega: 1 ≤ c) ((p.s.loc b).f p.x (t,i)) |
| refine ⟨hx.1,le_trans hx.2 ?_⟩ |
| rw [mul_zero,zero_add] |
| have hz' := he.ready.runs i he.holds x he.xem b a hp |
|
|
| omit hu hc in |
| lemma street (hz:p.curve t i true x=some y):Liaison p y u t i := |
| ⟨he.pays,(he.ready.swaps i he.holds x he.xem true y hz).1, he.holds,he.ready⟩ |
| end |
|
|
| def escort (s:Scheme) (f:Kiwi) (q:Cog) : Cog:= |
| .seq (walk s f true false) (.seq q (walk s f false false)) |
| variable {p:Dome}{u i x y t q z c:ℕ}{f:Kiwi} |
| (hu:p.Suite u)(hc:2 ≤ c)(he:Liaison p x u t i) |
| include hu hc he |
| lemma cups (hs:f.f p.x q=(t,i))(hz:p.curve t i true x=some y) (g:Cog) |
| {H v:ℕ}(hv: StampX q v p u c)(hr:(p.chord u y q).hear H c g 0 v): |
| (p.chord u x q).hear H c (escort p.s f g) 0 v:= by |
| rintro _ ⟨f,hf,rfl⟩ |
| exact .seq (stroll hu hc he (seal0 p hu hc) true f hf hs hz) (.seq |
| (hr _ ⟨f,hf,rfl⟩) (stroll hu hc (street he hz) |
| hv false f hf hs (he.ready.swaps i he.holds x he.xem true y hz).2)) |
|
|
| lemma bowls (hi: Bullet.roomS ≤ c) |
| (hs:f.f p.x q=(t,i))(hz:p.curve t i true x=some y) (g:Cog) |
| {H v:ℕ}{V:ℝ}(hr:(p.chord u y q).band c H v g V): |
| (p.chord u x q).band c H v (escort p.s f g) V:=by |
| obtain ⟨w,h⟩:=hr |
| have hb:Checked w (V/massB v (p.D u)) H:= (h _ ⟨clearG,p.cleared,rfl⟩).1 |
| have hp (t:ℕ)(ht:t ≤ H): hear (p.chord u y q) t c g 0 (enc (dsign w t)):= fun x hx=> |
| (h _ hx).2.digits t ht |
| exact ⟨w,fun a ha=> ⟨hb,⟨fun t ht=> cups hu hc he hs hz g (seal_mark _ hu hi hb ht) |
| (hp t ht) _ ha⟩⟩⟩ |
| end |
| end Pier |
|
|
| /- local switch after a small tag. cost raised simultaneously. -/ |
| namespace Iris |
| variable {p:Seats}{k m c:ℕ}{v:ℕ → Cog}{C:Cog} |
|
|
| abbrev matchQ (i:ℕ) : Flag:= ⟨_,Kn.next.left.eq (Kn.fix i)⟩ |
| def through (p:ℕ → Cog):ℕ → Cog |
| | 0=>.seq Cargo.knock (p 0) |
| | i+1=>.bif (matchQ (i+1)) (.seq Cargo.knock (p (i+1))) (through p i) |
| def dial (u:Cog)(p:ℕ → Cog)(i:ℕ):Cog:= |
| .seq (Cog.ren ⟨_,Cargo.stripK⟩ u) (through p i) |
|
|
| lemma remise (q:Port){c k a t m:ℕ}{v:ℕ → Cog}(h:k ≤ m) |
| (hi:q.l.state c ⟨q.w,t⟩ (k,q.src))(he:q.comp t c (v k) (q.s 0) (q.s a)): |
| q.comp t c (through v m) (q.s k) (q.s a):=by |
| have hf:q.comp t c (.seq Cargo.knock (v k)) (q.s k) (q.s a):= |
| .seq (etches _ _ (i:=k) rfl hi he.spots.1) he |
| induction m with |
| | zero=>have hv:k=0:=by omega |
| subst k |
| | succ i ih=> by_cases hh:k=i+1 |
| · subst k |
| exact .no (show decide (k=i+1)=false by simp [hh]) (ih (by omega)) |
|
|
| lemma rosary {t y:ℕ}(h:k ≤ m)(hp:p.rite c C k)(he:p.hear t c (v k) 0 y): |
| p.hear t c (dial C v m) 0 y:=by |
| intro x hx |
| exact .seq hz (remise (p.seat x) h hz.spots.2 (he x hx)) |
| lemma parcel {H v0:ℕ}{V:ℝ}(h:k ≤ m)(hp:p.rite c C k)(he:p.band c H v0 (v k) V): |
| p.band c H v0 (dial C v m) V:=by |
| obtain ⟨w,hq⟩:=he |
| have he(t:ℕ)(hr:t ≤ H): p.hear t c (v k) 0 (enc (dsign w t)):= fun x hx=> (hq x hx).2.digits t hr |
| exact ⟨w,fun _ hx=> ⟨(hq _ hx).1,⟨fun t ht=> rosary h hp (he t ht) _ hx⟩⟩⟩ |
| end Iris |
|
|
| end ExactDerandomization.Arena |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Arena |
| open Counter Relay Rill Glass Fret Mint Swirl Finset Chime Scheme Glass.Rod |
| open Fret.Seats Chime.Dome Pier |
| noncomputable section |
| open scoped Classical |
|
|
| namespace Flash |
|
|
| /-- Probe a pure function of (info, cursor) before any descent. -/ |
| def search (g:Cub (ℕ×ℕ) ℕ):Cog := |
| let h:= (g.runs.comp ((tokenK.left.comp Kn.first).tuple |
| (((Kn.unpack (α:=Foot)).comp Kn.next.right)).left)) |
| Cog.edit ⟨_,h.tuple Kn.next.right⟩ |
|
|
| variable (p:Dome) {u c q x:ℕ} |
| lemma found (hu:p.Suite u)(hx:x∈p.P)(hc:2 ≤ c) |
| {g:Cub (ℕ×ℕ) ℕ}{m:ℕ}(hg:g.f p.x (q,x)=m)(hp:StampX q m p u c): |
| (p.chord u x q).rite c (search g) m:=by |
| rintro _ ⟨a,ha,rfl⟩ |
| let S:= (p.chord u x q).seat (glove a x) |
| have hf:S.OK:=hu.pit hx _ _ ⟨a,ha,rfl⟩ |
| refine Lot.Mane.edit ?_ (plight (p:=S) (seal0 p (q:=q) hu hc) hf (by omega)) (plight (p:=S) hp hf (by omega)) |
| change (g.f _ ((Scheme.token _).1,(dec _:Foot).1),_)=_ |
| simp only [token,postcard,glove,dec_round] |
| def plumb (m:ℕ):Cog:= etch (α:=ℕ) (fun _ _=>m) (Kn.fix m) |
| lemma pureQ (hu:p.Suite u)(hx:x∈p.P)(hc:2 ≤ c) |
| (m:ℕ)(hp:StampX q m p u c) : (p.chord u x q).rite c (plumb m) m:= by |
| exact pointed0 (hu.pit hx q) hc (seal0 p (q:=q) hu hc) hp |
| abbrev chose (g:Cog)(w:ℕ):Cog:=Cargo.choose g Cargo.knock (plumb w) |
| abbrev win(a n:ℕ):ℕ:= if a=0 then 0 else n |
| lemma picks (hu:p.Suite u)(hx:x∈p.P)(hc:2 ≤ c)(a n:ℕ){g:Cog} |
| (hg:(p.chord u x q).rite c g a)(hp:StampX q n p u c) : |
| (p.chord u x q).rite c (chose g n) (win a n):=by |
| apply Seats.steer hg |
| · intro h |
| intro h |
|
|
| abbrev demand (g w:Cog):Cog:=Cargo.choose g Cargo.knock w |
| lemma wanted (hu:p.Suite u)(hx:x∈p.P)(hc:2 ≤ c)(a n:ℕ){g w:Cog} |
| (hg:(p.chord u x q).rite c g a)(hw:a≠0→(p.chord u x q).rite c w n) : |
| (p.chord u x q).rite c (demand g w) (win a n):=by |
| apply Seats.steer hg |
| · intro h |
| intro h |
| lemma win_stamped (hu:p.Suite u)(hc:2 ≤ c)(a n:ℕ)(he:StampX q n p u c): |
| StampX q (win a n) p u c:= by unfold win |
| lemma brilliant(p b:Bool) : win (enc p) (enc b)=enc (p&&b):=by cases p < |
|
|
| /-- Two threshold constants compiled as motions.Literal recipes are |
| regenerated without using the cursor. -/ |
| lemma gild (u v:ℕ)(_:u ≤ v):1 ≤ v+1:= Nat.le_add_left _ _ |
| abbrev clan (f:Sight)(w:ℕ):Kiwi:=⟨_, f.runs.tuple (Kn.fix w)⟩ |
|
|
| abbrev garnish (P:Cub ℕ (ℕ×ℕ×NoteM)): Sight:= |
| let h:= Kn.wash.comp (P.runs.left.tuple (Kn.wash.comp P.runs.right)) |
| ⟨_,h⟩ |
| /-- one visit interpreted as a boolean at the endpoint, payload already rebased. -/ |
| lemma maskB {h:Harp}{v:Harp.Wick}{b i x q:ℕ}{f:Option (ℕ×ℕ)}{C:Cub ℕ (ℕ×ℕ×NoteM)} |
| (hu:v.d.Suite u)(hx:x∈v.d.P)(hc:2 ≤ c)(hh:v.d.W b+v.d.D u ≤ v.d.W u) |
| (hz:v.Veil h b){m:NoteM}(hr:C.f v.d.x q=(b,i,m))(he:v.Ok m) |
| (hf:v.r.Flora h.p b i x f)(a:Bool) |
| (ha:match f with |
| | none=>a=false |
| | some (_,y) => ∀ p,v.d.r.proper p→ h.lit v.d.x m y p=(a,p)): |
| (v.d.chord u x q).rite c (Dome.Bullet.snap (garnish C)) (enc a) :=by |
| have hg:(garnish C).f v.d.x q=hole b (enc (i,m)):=by |
| change enc ((C.f _ _).1,enc (C.f _ _).2)=_ |
| rw [hr] |
| apply Bullet.copy v.d hu hc hx hh hg (t:=0) (seal_bit _ hu hc (q:=q) a) |
| intro p hp |
| have ht:= hz _ _ he _ _ hf p hp |
| change v.d.talk _ _ _ |
| cases f with |
| | none=> have hs:a=false:=ha |
| subst a |
| | some g=> obtain ⟨t,y⟩:=g |
| dsimp only [Harp.Wick.state] at ha ht |
| rw [ha p hp] at ht |
|
|
| end Flash |
|
|
| structure Gate where |
| grab:Cog |
| top:ℕ |
| hue:Sight |
| loyal:Cog |
| namespace Gate |
| variable (g:Gate) |
| open Flash |
| abbrev reach (k:ℕ):Kiwi:=clan g.hue (k-1) |
| def garden (s:Scheme):Cog:= |
| let w(k):= if k=0 then Cargo.knock else |
| Pier.escort s (g.reach k) (chose g.loyal k) |
| Iris.dial g.grab w g.top |
| def openE (s:Scheme)(f:ℕ → Cog) : Cog := |
| Iris.dial (g.garden s) f g.top |
|
|
| variable (p:Dome) |
| structure Crest (p:Dome) (u q c x i:ℕ):Prop where |
| safe:(p.chord u x q).rite c g.grab i |
| upper0:i ≤ g.top |
| east:p.Suite u |
| fine:x∈p.P |
| tall:2 ≤ c |
| nice:StampX q i p u c |
| namespace Crest |
| variable {p:Dome}{g:Gate}{u q c x y i z:ℕ} |
| lemma asleep (h:g.Crest p u q c x 0): |
| (p.chord u x q).rite c (g.garden p.s) 0:=by |
| apply Iris.rosary (t:=0) h.upper0 h.safe |
| exact blankD (h.east.pit h.fine q) h.tall |
| lemma morning (h:g.Crest p u q c x i)(he:i≠0){t:ℕ}(hc:g.hue.f p.x q=t) |
| (ht:Liaison p x u t (i-1))(hz:p.curve t (i-1) true x=some y) |
| (hp:(p.chord u y q).rite c g.loyal z): |
| (p.chord u x q).rite c (g.garden p.s) (win z i):=by |
| apply Iris.rosary h.upper0 h.safe |
| rw [ite_eq_right he] |
| apply cups h.east h.tall ht ?_ hz _ (win_stamped p h.east h.tall z i h.nice) |
| (picks p h.east (street ht hz).xem h.tall z i hp h.nice) |
| exact congrArg (fun m=> (m,i-1)) hc |
| end Crest |
| end Gate |
| end |
| end ExactDerandomization.Arena |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Arena |
| open Counter Relay Rill Glass Fret Mint Swirl Finset Chime Scheme Glass.Rod |
| open Fret.Seats Chime.Dome Pier Fret.Lyric Reed.Lu |
| noncomputable section |
| open scoped Classical |
|
|
| namespace Amber |
| /-- Enter a transparent Bernoulli coin (pure rational expression). -/ |
| abbrev Tear:=Cub History Coin |
| abbrev here (g:Tear) :Cub CoinQuery Coin := |
| ⟨_,g.runs.comp (Kn.first.tuple (((Kn.unpack (α:=Foot)).comp Kn.next).left))⟩ |
| abbrev moonF (g:Tear)(c:ℕ):Lyric:=.solo c (here g) |
| abbrev opaque0(f:Sight)(i:ℕ):Lyric:=.use i (Bullet.snap f) |
| abbrev syrup (g:Coin):Tear:=⟨_,Kn.fix g⟩ |
| abbrev first0 (g:Cub ℕ Coin):Tear:=⟨_,g.runs.comp Kn.first⟩ |
| abbrev awry(p:Knob)(i:ℕ):Tear:= first0 ⟨_,scaleK p i⟩ |
|
|
| variable {p:Dome} {a q x y T H n:ℕ} {c d m:ℕ} {k:Knob} |
| lemma occlude (he:Standard (p.chord a x q) k H)(g:Tear)(r:ℕ) |
| {v:ℝ}(hh:(g.f p.x (q,x)).v=v)(hb:|v| ≤ massB r (p.D a)): |
| Chor k c H (p.chord a x q) (moonF g r) v:=by |
| subst v |
| apply Chor.played he.st he.he ?_ hb |
| rintro _ ⟨a,ha,rfl⟩ |
| change g.f _ (_,(dec (glove _ _):Foot).1)=_ |
| rw [glove,dec_round] |
| lemma scalingF (he:Align (p.chord a x q).head k)(r:ℕ): |
| ((awry k r).f p.x (q,x)).v=massB r (p.D a):= scalen he .. |
|
|
| lemma normalizeF (u:p.Suite a)(r:Sight)(hc:Bullet.roomS ≤ c)(hi:x∈p.P) |
| {b n t j:ℕ}(hf:r.f p.x q = hole b n)(he:p.W b+p.D a ≤ p.W a) |
| {v:ℝ}(hg:p.Voice b x n t j v)(hh:H ≤ t): |
| band (p.chord a x q) c H 0 (Bullet.snap r) (v/(2:ℝ)^j):=by |
| refine Bullet.clef p u hc hi he hf hh ?_ |
| obtain ⟨w,h,hv⟩:=hg |
|
|
| abbrev shade (f:Cog)(c:ℕ)(g:Tear):Lyric:= times (.use 0 f) (moonF g c) |
| abbrev petal(r:Sight)(c:ℕ)(g:Tear):Lyric:= shade (Bullet.snap r) c g |
| abbrev blossoms(f:Kiwi)(s:Scheme)(r:Sight)(c:ℕ)(g:Tear):Lyric := shade (Pier.escort s f (Bullet.snap r)) c g |
| lemma cast {f:Cog}{g:Tear}{j r:ℕ}(he:Standard (p.chord a x q) k H) |
| {v:ℝ}(hh:band (p.chord a x q) c H 0 f (v/(2:ℝ)^j)) |
| (hb:(g.f p.x (q,x)).v=(2:ℝ)^j)(hr:(2:ℝ)^j ≤ massB r (p.D a)): |
| Chor k c H (p.chord a x q) (shade f r g) v:=by |
| have hf:=occlude (c:=c) he g r hb (by rwa [abs_of_pos (by positivity)]) |
| convert he.mult0 (Chor.byear hh) hf using 1 |
| lemma pour (u:p.Suite a)(r:Sight)(hc:Bullet.roomS ≤ c)(hi:x∈p.P) |
| {b n t j:ℕ}(hf:r.f p.x q = hole b n)(he:p.W b+p.D a ≤ p.W a) |
| {v:ℝ}(hg:p.Voice b x n t j v)(hh:H ≤ t) |
| (h0: Standard (p.chord a x q) k H){g:Tear}{d:ℕ}(hv:(g.f p.x (q,x)).v=(2:ℝ)^j) |
| (hl:(2:ℝ)^j ≤ massB d (p.D a)):Chor k c H (p.chord a x q) (petal r d g) v := |
| cast h0 (normalizeF u r hc hi hf he hg hh) hv hl |
| lemma seeds {f:Kiwi}(u:p.Suite a)(r:Sight)(hc:Bullet.roomS ≤ c){ψ m:ℕ} |
| (h:Liaison p x a ψ m) (hs:f.f p.x q=(ψ,m)) |
| (hz:p.curve ψ m true x=some y) |
| {b n t j:ℕ}(hf:r.f p.x q = hole b n)(he:p.W b+p.D a ≤ p.W a) |
| {v:ℝ}(hg:p.Voice b y n t j v)(hh:H ≤ t) |
| (h0: Standard (p.chord a x q) k H){g:Tear}{d:ℕ}(hv:(g.f p.x (q,x)).v=(2:ℝ)^j) |
| (hl:(2:ℝ)^j ≤ massB d (p.D a)):Chor k c H (p.chord a x q) (blossoms f p.s r d g) v :=by |
| have hr:2 ≤ c:=by unfold Bullet.roomS at hc |
| apply cast h0 _ hv hl |
| apply bowls u hr h hc hs hz |
| exact normalizeF u r hc (street h hz).xem hf he hg hh |
|
|
| /-- Ballot compilation including explicit reset to desired output exponent. |
| (Called only on successful gate, fallback zero separately). -/ |
| abbrev roost (r:Knob)(f:Lyric)(v:ℕ) : Cog:= Lyric.choir r (reset f v) |
| lemma onQ {s:Seats} (r:Knob)(f:Lyric)(v:ℕ)(ht: Standard s r T) |
| {x:ℝ}(hp:Chor r c T s f x)(hc:1 ≤ c) (he:H+(tail (reset f v))*s.d ≤ T) |
| (hs:(cost (reset f v) c) ≤ d) (hr:|x| ≤ massB v s.d) : |
| s.band d H v (roost r f v) x:= Seats.flex (sing (ht.ring0 hp _ hr) hc he) |
| (cost_hi (p:=reset f v) hc) hs le_rfl |
|
|
| abbrev snow (r:Knob)(v:ℕ) : Cog:= Lyric.choir r (son 0 v) |
| lemma steam {s:Seats} (r:Knob)(v:ℕ)(ht:Standard s r H) |
| (hs:powder 100 ≤ c): s.band c H v (snow r v) 0:= by |
| have hp:Chor r 2 H s (son 0 v) 0:=by simpa only [Nat.cast_zero] using ht.shins 2 v 0 (by simp) |
| exact flex (sing hp (by omega) (by simp [son,tail])) (cost_hi (p:=son 0 v) (c:=2) (by omega)) hs le_rfl |
| end Amber |
| end |
| end ExactDerandomization.Arena |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Arena |
| open Hie Analysis Counter Relay Rill Glass Fret Mint Swirl Finset Chime Scheme Glass.Rod |
| open Fret.Seats Chime.Dome Pier Fret.Lyric Reed.Lu |
| noncomputable section |
| open scoped Classical |
| namespace Song |
|
|
| variable (a:Cub ℕ Bool) {P:Seats} |
| abbrev provided :Flag:= ⟨_,a.runs.comp (tokenK.left.comp Kn.first)⟩ |
| def pleas (p q:Cog):Cog:= Cog.bif (provided a) p q |
| lemma picked {b _ _ _ _:ℕ}:0≤b:=Nat.zero_le _ |
| lemma park {t c:ℕ} {f g:Cog}{r s:Site}{v:Port} |
| (hp:a.f v.l.x v.info=true)(he:v.comp t c f r s):v.comp t c (pleas a f g) r s:= |
| Lot.Mane.yes (by change a.f _ ((token (postcard _ _)).1)=_ |
| lemma parks {t c:ℕ} {f g:Cog}{r s:Site}{v:Port} |
| (hp:a.f v.l.x v.info=false)(he:v.comp t c g r s):v.comp t c (pleas a f g) r s:= |
| Lot.Mane.no (by change a.f _ ((token (postcard _ _)).1)=_ |
| lemma pinTrue {i T c:ℕ}{v:ℝ}{f g} (hp:a.f P.l.x P.info=true)(ht:P.band c T i f v): |
| P.band c T i (pleas a f g) v:=by |
| obtain ⟨w,h⟩:=ht |
| exact ⟨w,fun x hx=> ⟨(h _ hx).1,⟨fun t ht=>park a hp ((h _ hx).2.digits t ht)⟩⟩⟩ |
| lemma pinFalse {i T c:ℕ}{v:ℝ}{f g} (hp:a.f P.l.x P.info=false)(ht:P.band c T i g v): |
| P.band c T i (pleas a f g) v:=by |
| obtain ⟨w,h⟩:=ht |
| exact ⟨w,fun x hx=> ⟨(h _ hx).1,⟨fun t ht=>parks a hp ((h _ hx).2.digits t ht)⟩⟩⟩ |
|
|
| /-- Constant scalar polymer. fourth powers of rising -/ |
| abbrev ein:= kohn 1 |
| abbrev deuce:=kohn 2 |
| abbrev divN (f:Lyric)(n:ℕ) : Lyric := times f (bi .flip (kohn n) zeroE) |
| def sQ (f:Lyric) : Lyric:= Reed.Lu.inf ein (Reed.Lu.sup zeroE f) |
| def quat (f:Lyric):Lyric:= let q:=times f f |
| def takeF(f:Lyric):Lyric:= quat (sQ (times deuce f)) |
| def faded (f:Lyric):Lyric:= divN (psum (takeF f) (diff ein (takeF (diff ein f)))) 2 |
|
|
| def boostR (f:Lyric): Lyric:= faded (diff (times (kohn 4) f) ein) |
| def gammaR (f:Lyric): Lyric:= diff ein (faded (divN (diff (times (kohn 10) f) (kohn 5)) 3)) |
|
|
| namespace Paint |
| variable {k s T c f} {x:ℝ} (h:Standard s k T) (he:Chor k c T s f x) |
| include h he |
| lemma divideF (i:ℕ)(hi:1 ≤ i): Chor k c T s (divN f i) (x/(i:ℝ)):=by |
| have hz := (h.rove c i).minuet h.sil h.st Doop.flip |
| apply Eq.mp _ (h.mult0 he hz) |
| rw [show Doop.val .flip _ 0 = (i:ℝ)⁻¹ from ?_,div_eq_mul_inv] |
| change (max (i:ℝ) 1)⁻¹=(i:ℝ)⁻¹ |
| lemma between0 : Chor k c T s (sQ f) (smooth x):=by |
| exact h.lo0 (by simpa only [Nat.cast_one] using h.rove c 1) (h.up0 h.sil he) |
| lemma quadrat:Chor k c T s (quat f) (x^4):=by |
| convert h.mult0 (h.mult0 he he) (h.mult0 he he) using 1 < |
| lemma tapS : Chor k c T s (takeF f) (smooth (2*x)^4):=by |
| apply quadrat h |
| exact h.mult0 (h.rove c 2) he |
| lemma went : Chor k c T s (faded f) (fade x):=by |
| have hs:Chor k c T s ein 1:= by simpa only [Nat.cast_one] using h.rove c 1 |
| apply divideF h _ 2 (by omega) |
| exact h.additions (tapS h he) (h.dubs hs (tapS h (h.dubs hs he))) |
| lemma boosted : Chor k c T s (boostR f) (boost x):=by |
| have hs := went h (h.dubs (h.mult0 (h.rove c 4) he) (h.rove c 1)) |
| convert hs using 1 < |
| lemma gammed : Chor k c T s (gammaR f) (gamma x):=by |
| have hs:=h.dubs (h.rove c 1) (went h (divideF h (h.dubs (h.mult0 (h.rove c 10) he) |
| (h.rove c 5)) 3 (by omega))) |
| convert hs using 1 < |
| end Paint |
| end Song |
|
|
| end |
| end ExactDerandomization.Arena |
|
|
| end |
|
|
| end OAI |
|
|
