| import OAI.Computability.Logspace.IterationSchedule |
| import OAI.Computability.Logspace.RowEvaluation |
|
|
| namespace OAI |
|
|
| /-! |
| Uniform configuration, copy-arc, and reward evaluation. |
|
|
| From OpenAI, *Exact Derandomization of Logarithmic Space: L = RL = BPL*. |
| -/ |
|
|
| set_option autoImplicit true |
|
|
| section |
|
|
| namespace ExactDerandomization.Spring |
| 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 Glass Glass.Rod |
| noncomputable section |
| open scoped Classical |
| variable {q w h:ℕ} |
|
|
| namespace Aqua |
|
|
| variable (r:Rock q w h) |
|
|
| def tally (x:Word)(i:ℕ):ℕ:= |
| r.P.size x * min (r.n x) (r.w.p.M^i) |
| lemma tallyK {α}[Wire α]{i:PT α ℕ}(he:Kn i):Kn (fun x a=>tally r x (i x a)):= |
| (show Kn (fun x (_:α)=>r.P.size x) from fun _ _=>r.P.eSize).times (Kn.cap r.nKn (Kn.fix _) he) |
|
|
| section |
| variable {u:Line (q:=q) (w:=w) (h:=h)} |
| lemma wideT {_ i:ℕ}:0 ≤ i:=Nat.zero_le _ |
| lemma tank (_:u.Chart) (i:ℕ): |
| (u.plotM.stage i).S=range (u.r.P.size u.x*u.w0.p.M^i):=by |
| let M:=u.w0.p.M |
| have hM:0<M:=by have hp:=u.w0.p.mOK; dsimp only [M]; omega |
| induction i with |
| | zero=> rw [pow_zero,mul_one]; rfl |
| | succ i ih=> |
| rw [Scene.mature,Stg.next] |
| change copyZone (u.plotM.stage i).p.M (u.plotM.stage i).S=_ |
| rw [u.plotM.aligned,ih] |
| ext j; change j∈copyZone M _↔j∈range (_*M^(i+1)) |
| rw [member_copy hM,mem_range,mem_range] |
| rw [Nat.div_lt_iff_lt_mul hM,pow_succ,mul_assoc] |
| lemma maxv (e:u.Chart) {i:ℕ}(hi:i ≤ u.B): |
| tally u.r u.x i = u.r.P.size u.x *u.r.w.p.M ^ i:=by |
| have hs:=e.sc |
| have hk : u.w0.p.M ≤ 2^u.w0.p.M:=le_trans (by omega) (exp_big _) |
| let m:=u.w0.p.M |
| have hh : m^i ≤ (2:ℕ)^(u.w0.ceiling u.B):=le_trans (Nat.pow_le_pow_left hk i) (by |
| rw [←pow_mul] |
| apply Nat.pow_le_pow_right (by omega) |
| unfold Wares.ceiling Wares.density |
| have ht:=Nat.mul_le_mul_left m hi |
| unfold m at ht;nlinarith) |
| unfold tally |
| rw [min_eq_right (show m^i ≤ u.n from le_trans hh hs.fuel)] |
| lemma room (e:u.Chart) {i:ℕ}(hi:i ≤ u.B): |
| range (tally u.r u.x i)=(u.plotM.stage i).S:=by rw [tank e,maxv e hi] |
| end |
|
|
| def dbox (n k:ℕ):Coin:=Coin.ofZ ((min n (2^k))^4:ℕ) |
| abbrev qua (n k:ℕ):Coin:=Coin.inv (dbox n k) |
| def qq (n k:ℕ): Coin:=Coin.mult (Coin.ofZ ((side n k)^4:ℕ)) (Coin.inv (Coin.ofZ (n^4:ℕ))) |
| def quo (n a k:ℕ):Coin:= |
| Coin.mult (Coin.mult (qua n k) (dbox n a)) |
| (Coin.mult (qq n a) (Coin.inv (qq n (max a k)))) |
| def rawcoins(n k:ℕ):Coin:= Coin.mult (qua n k) (Coin.inv (qq n k)) |
| def sbase(n k:ℕ):Coin:=Coin.mult (Coin.inv (Coin.ofZ 2)) (dbox n k) |
|
|
| def zet :Coin:=Coin.place 1 (4096*400*1000000*1000) |
| lemma coinZ : zet.v=zeta:=by norm_num [zet,zeta,At.small,delta,Hie.A,Coin.place,Coin.v] |
|
|
| section |
| variable {α}[Wire α]{n a k:PT α ℕ} |
| lemma dboxK (h:Kn n)(he:Kn k):Kn (fun x p=>dbox (n x p) (k x p)):= |
| Coin.ofK (((Kn.cap h (Kn.fix 2) he).power 4).ZofN) |
| lemma qqK (h:Kn n)(he:Kn k):Kn (fun x p=>qq (n x p) (k x p)):= |
| Coin.multK (Coin.ofK (((Print.asideK h he).power 4).ZofN)) (Coin.invK (Coin.ofK ((h.power 4).ZofN))) |
| lemma largeK {α}[Wire α]{t s:PT α ℕ}(h:Kn t)(e:Kn s):Kn (fun x a=>max (t x a) (s x a)):=by |
| simpa only [max_def] using h.cond_le e e h |
| lemma quoK(h:Kn n)(ht:Kn a)(he:Kn k):Kn (fun x p=>quo (n x p) (a x p) (k x p)):=by |
| exact Coin.multK (Coin.multK (Coin.invK (dboxK h he)) (dboxK h ht)) (Coin.multK (qqK h ht) |
| (Coin.invK (qqK h (largeK ht he)))) |
| lemma rawK (h:Kn n)(he:Kn k):Kn (fun x p=>rawcoins (n x p) (k x p)):= |
| Coin.multK (Coin.invK (dboxK h he)) (Coin.invK (qqK h he)) |
| end |
| variable {n:ℕ} [Fact n.Prime] |
| omit [Fact (Nat.Prime n)] in |
| lemma priceT {k:ℕ}(h:2^k ≤ n):(dbox n k).v=(rate k)⁻¹:=by simp [dbox,rate,h] |
| omit [Fact (Nat.Prime n)] in |
| lemma priceV {k:ℕ}(h:2^k ≤ n):(qua n k).v=rate k:=by rw [Coin.inv0,priceT h, inv_inv] |
| omit [Fact (Nat.Prime n)] in |
| lemma pc (k:ℕ):(qq n k).v=pct n k:=by simp [qq,pct]; ring_nf |
| omit [Fact (Nat.Prime n)] in |
| lemma pureG {a k:ℕ}(h:2^(nar a k) ≤ n): (quo n a k).v=loaded n a k:=by |
| have ha:2^a ≤ n:= le_trans (Nat.pow_le_pow_right Nat.zero_lt_two (le_max_left ..)) h |
| have hk: 2^k ≤ n:= le_trans (Nat.pow_le_pow_right Nat.zero_lt_two (le_max_right ..)) h |
| simp only [quo,Coin.mul0,priceT ha,priceV hk,Coin.inv0,pc] |
| unfold loaded nar; ring_nf |
| omit [Fact (Nat.Prime n)] in |
| lemma raw (k:ℕ)(h:2^k ≤ n):(rawcoins n k).v=peeler n k:=by |
| rw [rawcoins,Coin.mul0,priceV h,Coin.inv0,pc,peeler,div_eq_mul_inv] |
| omit [Fact (Nat.Prime n)] in |
| lemma seed (k:ℕ)(h:2^k ≤ n): (sbase n k).v=(2:ℝ)⁻¹*(rate k)⁻¹:=by |
| simp [sbase,priceT h] |
| end Aqua |
|
|
| namespace WindY |
| abbrev tx:ℕ:=Fintype.card Env.Atom |
| lemma nowM : 0<tx:=Fintype.card_pos |
| variable (r:Rock q w h) |
| def shower (x:Word) (j:ℕ):Coin:= |
| let s:= 2^(planets r x*(r.w.ell * lb tx)) |
| Coin.inv (Coin.ofZ ((min s (tx^j)):ℕ)) |
| lemma showerK {α}[Wire α]{g :PT α ℕ}(h:Kn g):Kn (fun x a=>shower r x (g x a)):= |
| Coin.invK (Coin.ofK ((Kn.cap (upclock r _) (Kn.fix _) h).ZofN)) |
| lemma rains (x: Word){l:ℕ}(h:l ≤ r.w.ell*Moon.M r x): |
| (shower r x l).v=Env.weight^l:=by |
| unfold shower; dsimp only |
| have he:=below tx |
| have hh: tx^l ≤ 2^(planets r x * (r.w.ell*lb tx)):=by |
| refine le_trans (Nat.pow_le_pow_left he.le l) ?_ |
| rw [← pow_mul] |
| apply Nat.pow_le_pow_right (by omega) |
| refine le_trans (Nat.mul_le_mul_left _ h) ?_ |
| have ht:Moon.M r x ≤ planets r x:=by unfold planets; omega |
| nlinarith [Nat.mul_le_mul_right (r.w.ell*lb tx) ht] |
| rw [min_eq_right hh,Coin.inv0,Coin.ofv] |
| simp [Env.weight,tx,inv_pow] |
| lemma careful (l:ℕ):0 ≤ Env.weight^l ∧ Env.weight^l ≤1:=by |
| have h:0≤Env.weight:=by unfold Env.weight; positivity |
| have hs : 1 ≤ (tx:ℝ) := by exact_mod_cast nowM |
| have hv:Env.weight ≤1:=by apply inv_le_one_of_one_le₀ hs |
| exact ⟨by positivity,pow_le_one₀ h hv⟩ |
| end WindY |
|
|
| /- environment remap for copy arcs -/ |
| namespace Prism |
| def swap (n M i j:ℕ) (s:Issue):Issue:= (Print.stretch n M i s.1,Print.stretch n M j s.2.1,s.2.2) |
| lemma swapK {α}[Wire α]{n i j:PT α ℕ}{s:PT α Issue}(hn:Kn n)(hi:Kn i)(hj:Kn j)(hs:Kn s)(M): |
| Kn (fun x a=> swap (n x a) M (i x a) (j x a) (s x a)):= |
| (Print.stretchK hn (Kn.fix M) hi hs.left).tuple ((Print.stretchK hn (Kn.fix M) hj hs.right.left).tuple hs.right.right) |
| lemma masked {n M:ℕ} [Fact n.Prime](h:0<M)(he:M<n)(i j:ℕ)(s:Pool n) : |
| swap n M i j (Print.issued s)=Print.issued (Est.pane M i j s):=by |
| have hs:(M:ZMod n)≠0:=by |
| intro hm; have hh:=congrArg ZMod.val hm |
| rw [ZMod.val_natCast,Nat.mod_eq_of_lt he,ZMod.val_zero] at hh; omega |
| unfold swap Print.issued |
| erw [Print.stretchy _ _ _ hs,Print.stretchy _ _ _ hs] |
| simp only [pane,replica,dite_eq_right hs]; rfl |
| def leftE (s:Issue):Issue:=(s.1,s.2.2,s.2.1) |
| def rightE (s:Issue):Issue:=(s.2.2,s.2.1,s.1) |
| def crossE (s:Issue):Issue:=(s.2.1,s.1,s.2.2) |
|
|
| end Prism |
| end |
| end ExactDerandomization.Spring |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Spring |
| 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 Glass Glass.Rod Rain |
| noncomputable section |
| open scoped Classical |
|
|
| namespace Garden |
|
|
| variable (w:Wares) |
| abbrev fence(a:Crt):Scout:= Age.styx a |
| abbrev m(a:Crt):=Age.MV a |
| abbrev origin(a:Crt):= (fence a).2.1 |
| abbrev stageQ(a:Crt):=(fence a).1.1 |
| abbrev params(a:Crt):ID:= (fence a).1 |
| abbrev greenY(a:Crt):=(fence a).1.2.2.1 |
| abbrev matchZ(a:Crt):=(fence a).2.2.2 |
| abbrev countO(a:Crt):= if origin a=1 then w.p.T else (fence a).2.2.1 |
|
|
| def asker (a:Crt) := (range (greenY a+m a+1)).filter fun k=> (if origin a=0 then stageQ a-1 else stageQ a) ≤ k+pad w.p |
| def foreground (a:Crt)(b:Bool):Finset Ray:= |
| if b then |
| if origin a=0 then (if stageQ a=0 then ∅ else asker w a ×ˢ range (w.p.M*w.p.M)) |
| else (asker w a ×ˢ range (if countO w a=0 then 1 else 2) ∪ |
| if origin a=1 then {(stageQ a,2)} else ∅) |
| else if matchZ a=true ∧ origin a≠4 then {(greenY a,0)} else ∅ |
|
|
| def atmos (c:Crt)(q:Seed):Prop := |
| q=Seed.along q.2 q.x q.y ∧ q.x<w.p.K∧q.y<w.p.K ∧ |
| q.fog.habitat w (greenY c) (m c) (Age.g c) (foreground w c q.fog.first0) |
| def retired(c:Crt) (q:Seed):Prop:= |
| q=Seed.old true q.x ∧ Age.g c ≠ 0 ∧ q.x < capacity 2 w.p.K (Age.L (m c)) (Age.g c-1) |
| def began(c:Crt) (q:Seed):Prop:= |
| q=Seed.old false q.x ∧ Age.g c=0∧ origin c=0 ∧ stageQ c=0∧ q.x<2 |
| def ace (c:Crt)(q:Seed):Prop:=atmos w c q ∨ retired w c q ∨ began c q |
|
|
| abbrev Lead:=Crt × Seed |
| abbrev Pan:=ℕ×ℕ |
| def clean (w:Wares)(p:Pan):Bool:=decide (enc (dec p.2:Seed)=p.2 ∧ ace w (dec p.1) (dec p.2)) |
| namespace Plot |
| open Helix.GK |
| variable {α β}[Wire α][Wire β]{b:PT α Bool}{n k :PT α ℕ} |
| lemma wall {f h:PT α β}(hp:Kn f)(he:Kn h):GK (fun x a=> f x a=h x a):=by |
| convert eqG (Kn.wash.comp hp) (Kn.wash.comp he) using 1 |
| ext x a; exact ⟨fun e=>congrArg enc e,fun v=>(Wire.eq _).symm.trans ((congrArg dec v).trans (Wire.eq _))⟩ |
| lemma matt {f g:PT α Prop}(h:Kn b)(he:GK f)(hg:GK g):GK (fun x a=> if b x a then f x a else g x a):=by |
| let h1:=GK.forth h |
| convert orG (h1.andG he) (h1.notG.andG hg) using 1 |
| ext x a; split <;> simp_all |
| lemma countEat (h:Kn n)(he:Kn k)(j:ℕ):GK (fun x a=> n x a<j^ (k x a)):=by |
| convert GK.ltG h (Kn.cap h.succ (Kn.fix j) he) using 1 |
| ext x a; omega |
| variable {a:PT α Crt}{r:PT α Ray}{f:PT α Fog}{s:PT α Seed} |
| lemma askG (h:Kn a)(g:Kn k):GK (fun x p=> k x p ∈ asker w (a x p)):=by |
| have p:=h.right.right.left |
| have hp:=p.left.left |
| let hx:=p.left.right.right.left.add h.right.left.left |
| convert (ltG g hx.succ).andG (leG (p.right.left.cond_eq (Kn.fix 0) hp.pred hp) |
| (g.add (Kn.fix (pad w.p)))) using 1 |
| ext x q; simp only [asker,mem_filter,mem_range] |
| lemma fgG (h:Kn a)(hp:Kn r)(hg:Kn b): |
| GK (fun x u=>r x u∈ foreground w (a x u) (b x u)) :=by |
| have he:=h.right.right.left |
| let i:=he.left.left |
| let t:=he.right.left |
| let N:= t.cond_eq (Kn.fix 1) (Kn.fix w.p.T) he.right.right.left |
| let k(e:ℕ):=GK.eqG t (Kn.fix e) |
| let so:= (forth he.right.right.right).andG ((k 4).notG) |
| let z:= wall hp (he.left.right.right.left.tuple (Kn.fix 0)) |
| let v:= asker w |
| let q:= askG w h hp.left |
| let u:= (GK.notG (eqG i (Kn.fix 0))).andG (q.andG (ltG hp.right (Kn.fix (w.p.M*w.p.M)))) |
| let Q:=q.andG (ltG hp.right (N.cond_eq (Kn.fix 0) (Kn.fix 1) (Kn.fix 2))) |
| let Z:= Q.orG ((k 1).andG (wall hp (i.tuple (Kn.fix 2)))) |
| convert matt hg (ifG u Z t (Kn.fix 0)) (so.andG z) using 1 |
| ext x a; unfold foreground; split <;> grind |
| |
| lemma fogK (h:Kn a)(e:Kn f):Kn (fun x u=> (f x u).ray (greenY (a x u))):= |
| let p:=h.right.right.left.left.right.right.left |
| let q:=e.left.right |
| (q.left.left.cond (p.add q.left.right) (p.sub q.left.right)).tuple q.right.left |
|
|
| lemma reachK {m g a k:PT α ℕ}(h:Kn m)(e:Kn g)(hp:Kn a)(he:Kn k): |
| Kn (fun x v=> Stair.reach ⟨m x v,0,⟨a x v,0,0⟩,w.ell⟩ (k x v) (g x v)) := |
| h.sub (Aqua.largeK (Age.gapK h e) (((hp.sub he).add (he.sub hp)).succ)) |
| lemma yokeK {m g a k:PT α ℕ}(h:Kn m)(e:Kn g)(hp:Kn a)(he:Kn k): |
| Kn (fun x v=> Stair.yoke ⟨m x v,0,⟨a x v,0,0⟩,w.ell⟩ (k x v) (g x v)):=by |
| convert e.cond_eq (Kn.fix 0) (Kn.fix 0) (reachK w h e.pred hp he) using 1 |
| ext x v; cases g x v <;> simp only [ite_true,Nat.succ_ne_zero,ite_false] <;> rfl |
| lemma habG (h:Kn a)(e:Kn f):GK (fun x p=> (f x p).habitat w (greenY (a x p)) (m (a x p)) (Age.g (a x p)) |
| (foreground w (a x p) (f x p).first0)):=by |
| have q:= fogK h e |
| let t:= e.left.right |
| let s:= h.right.left |
| let A:= h.right.right.left.left.right.right.left |
| let I:= (s.left.sub t.right.right).pred |
| let u:=(leG (yokeK w s.left s.right A q.left) I).andG |
| (ltG I (reachK w s.left s.right A q.left)) |
| let v:=eqG (s.left.sub I.succ) t.right.right |
| let V:= wall t.left (A.cond_le q.left ((Kn.fix true).tuple (q.left.sub A)) |
| ((Kn.fix false).tuple (A.sub q.left))) |
| let w':= countEat e.right.right ((Kn.fix w.ell).times t.right.right) Print.rad |
| convert (fgG w h q e.left.left).andG (u.andG (v.andG (V.andG w'))) using 1 |
| ext x a; unfold Fog.habitat Stair.layers; simp only [mem_Ico]; rfl |
| lemma atmosK(h:Kn a)(e:Kn s):GK (fun x p=>atmos w (a x p) (s x p)):= |
| let q:= e.left.right |
| (wall e (((Kn.fix (2:ℕ)).tuple q).tuple e.right)).andG |
| ((ltG q.left (Kn.fix _)).andG ((ltG q.right (Kn.fix _)).andG (habG w h e.right))) |
| lemma oldKn {q:PT α ℕ}(h:Kn q)(b:Bool):Kn (fun x p=>Seed.old b (q x p)):= |
| ((Kn.fix _).tuple (h.tuple (Kn.fix _))).tuple (Kn.fix _) |
| lemma retireK(h:Kn a)(e:Kn s):GK (fun x p=>retired w (a x p) (s x p)):= |
| let q:= e.left.right.left |
| let p:= h.right.left |
| let m:= (((Kn.fix (cexpo 2 w.p.K)).times (Age.gapK p.left p.right.pred)).times (Kn.fix 4)) |
| (wall e (oldKn q true)).andG ((notG (eqG p.right (Kn.fix 0))).andG (countEat q m 2)) |
| lemma beganK(h:Kn a)(e:Kn s):GK (fun x p=>began (a x p) (s x p)):= |
| let q:=e.left.right.left |
| let p:=h.right.right.left |
| (wall e (oldKn q false)).andG ((eqG h.right.left.right (Kn.fix 0)).andG |
| ((eqG p.right.left (Kn.fix 0)).andG ((eqG p.left.left (Kn.fix 0)).andG |
| (ltG q (Kn.fix 2))))) |
| lemma cleanK (h:Kn a)(e:Kn s): GK (fun x p=> ace w (a x p) (s x p)):= |
| (atmosK w h e).orG ((retireK w h e).orG (beganK h e)) |
| lemma basin : Kn (fun (_:Word)(p:Pan)=> Garden.clean w p) := |
| let h:= (Kn.unpack (α:=Seed)).comp (Kn.next (α:=ℕ)) |
| decideK ((eqG (Kn.wash.comp h) Kn.next).andG (cleanK w (Kn.unpack.comp Kn.first) h)) |
| end Plot |
| end Garden |
| end |
| end ExactDerandomization.Spring |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Spring |
| 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 Glass Glass.Rod Rain |
| open Cambria Cambria.Wear Garden |
| noncomputable section |
| open scoped Classical |
| variable {q w h:ℕ} |
|
|
| namespace Blade |
| abbrev Embellish:= Surf× Rus |
| def bald : Embellish:= default |
|
|
| namespace HullT |
| variable (r:Rock q w h) |
|
|
| abbrev determine(k:Crt)(b:Bool):ℕ:=if b then greenY k else (params k).2.2.2 |
| def tides (x:Word)(k:Crt)(b:Bool)(p:Rill.History) : Cambria.Hull:= |
| ((Aqua.tally r x (stageQ k),(params k).2.1,determine k b),p,dec (Age.env k)) |
| lemma tideK {α}[Wire α]{a:PT α Crt}{v:PT α Bool}{p:PT α Rill.History} |
| (h:Kn a)(e:Kn v)(ht:Kn p):Kn (fun x w=>tides r x (a x w) (v x w) (p x w)):= |
| let s:=h.right.right.left.left |
| let p:=s.right.right |
| ((Aqua.tallyK r s.left).tuple (s.right.left.tuple (e.cond p.left p.right))).tuple |
| (ht.tuple (Kn.unpack.comp h.right.right.right)) |
| end HullT |
|
|
| namespace Crest |
| abbrev portN (a i:ℕ):Rill.History:=(Was.atom i,a) |
| abbrev postN:= (Was.atom 0,((1,0):Arch)) |
| def pastC (c:Crt)(i:ℕ):ℕ:= enc (stint c i (Age.g c-1)) |
| def bronze (c:Crt)(h:Hull)(i:ℕ): Embellish:= |
| ((h,portN 0 0,(pastC c 4,i),postN),(0,false),Coin.ofZ 0,0,(pastC c 3,i),0) |
| def newelf(n k:ℕ)(h:Hull)(i:ℕ):Embellish:= |
| ((h,portN 0 (i+1),(0,0),postN),(1,true),Aqua.sbase n k,0,(0,0),0) |
|
|
| abbrev launch(k r:ℕ)(s:Scout)(q:Issue):ℕ:= enc (kit k (r,0) s (enc q)) |
| abbrev op (t f x:ℕ):ℕ:= hole t (hole f x) |
| def ordinary(h:Hull)(b:Bool)(r j:ℕ)(q:Scout)(p:Issue)(c:Coin): Embellish:= |
| ((h,portN 0 0,(launch 15 r q p,j),postN),(2,b),c,0,(launch 14 r q p,j),0) |
| def company(h:Hull)(r _ i j:ℕ)(q Q:Scout)(p:Issue)(c:Coin):Embellish:= |
| let x:= Prism.leftE p |
| let y:= Prism.rightE p |
| let u:= launch 14 r q x |
| ((h,(hole (launch 12 r q x) i,op u 0 i),(launch 15 r Q y,j),postN),(2,true), |
| c,op u 1 i,(launch 14 r Q y,j),0) |
| def twins(h: Hull)(r s:ℕ)(q:Scout)(i j M l n:ℕ)(p:Issue)(c:Coin):Embellish:= |
| let x:= Prism.swap n M i j p |
| ((h,portN 0 (3+(i+M)),(launch 15 r q x,s),(Was.atom (3+j),M,j)), |
| (2,true),c,0,(launch 14 r q x,s),if i=0 then 0 else launch 17 r (bitV (detector l 0)) x) |
|
|
| section |
| variable {α}[Wire α]{a:PT α Crt}{H:PT α Hull}{j n r i l k :PT α ℕ}{p q:PT α Scout}{s:PT α Issue}{c:PT α Coin} |
| lemma pastK (h:Kn a)(i):Kn (fun x b=>pastC (a x b) i):= |
| Kn.wash.comp ((Kn.fix _).tuple ((h.right.left.left.tuple h.right.left.right.pred).tuple h.right.right)) |
| lemma bronzeK (h:Kn a)(he:Kn H)(hk:Kn i):Kn (fun x b=>bronze (a x b) (H x b) (i x b)):= |
| (he.tuple ((Kn.fix _).tuple (((pastK h 4).tuple hk).tuple (Kn.fix _)))).tuple |
| ((Kn.fix _).tuple ((Kn.fix _).tuple ((Kn.fix _).tuple (((pastK h 3).tuple hk).tuple (Kn.fix _)) ))) |
| lemma opK (h:Kn n)(f:ℕ)(e:Kn i):Kn (fun x b=>op (n x b) f (i x b)):= |
| Kn.wash.comp (h.tuple (Kn.wash.comp ((Kn.fix f).tuple e))) |
| lemma portK (h:Kn i): Kn (fun x b=>portN 0 (i x b)):= |
| (Kn.wash.comp ((Kn.fix 0).tuple h)).tuple (Kn.fix 0) |
| lemma neoK (h:Kn n)(e:Kn k)(hu:Kn H)(hf:Kn i):Kn (fun x b=>newelf (n x b) (k x b) (H x b) (i x b)):= |
| (hu.tuple ((portK hf.succ).tuple (Kn.fix _))).tuple ((Kn.fix _).tuple ((Coin.multK (Kn.fix _) |
| (Aqua.dboxK h e)).tuple (Kn.fix _))) |
| lemma orbitK (n:ℕ)(h:Kn r)(e:Kn p)(hf:Kn s):Kn (fun x b=>launch n (r x b) (p x b) (s x b)):= |
| Kn.wash.comp ((Kn.fix n).tuple ((h.tuple (Kn.fix 0)).tuple (e.tuple (Kn.wash.comp hf)))) |
| lemma ordinaryK (h:Kn r)(e:Kn p)(hf:Kn s)(hg:Kn j)(hs:Kn H)(hx:Kn c)(b:Bool): |
| Kn (fun x a=>ordinary (H x a) b (r x a) (j x a) (p x a) (s x a) (c x a)):= |
| (hs.tuple ((Kn.fix _).tuple (((orbitK 15 h e hf).tuple hg).tuple (Kn.fix _)))).tuple |
| ((Kn.fix _).tuple (hx.tuple ((Kn.fix _).tuple (((orbitK 14 h e hf).tuple hg).tuple (Kn.fix _))))) |
| lemma companyK (h:Kn r)(e:Kn p)(hw:Kn q)(hf:Kn s)(hg:Kn j)(ht:Kn i)(hs:Kn H)(hx:Kn c)(_:Kn k): |
| Kn (fun x a=>company (H x a) (r x a) (k x a) (i x a) (j x a) (p x a) (q x a) (s x a) (c x a)):= |
| let L:=hf.left.tuple (hf.right.right.tuple hf.right.left) |
| let R:= hf.right.right.tuple (hf.right.left.tuple hf.left) |
| let t:= orbitK 14 h e L |
| let u:= orbitK 14 h hw R |
| (hs.tuple (((Kn.wash.comp ((orbitK 12 h e L).tuple ht)).tuple (opK t 0 ht)).tuple |
| (((orbitK 15 h hw R).tuple hg).tuple (Kn.fix _)))).tuple |
| ((Kn.fix _).tuple (hx.tuple ((opK t 1 ht).tuple ((u.tuple hg).tuple (Kn.fix _))))) |
| lemma twinK(h:Kn H)(he:Kn r)(hw:Kn k)(hx:Kn p)(hf:Kn i)(ht:Kn j)(M:ℕ)(hu:Kn l) |
| (hm:Kn n)(hD:Kn s)(hc:Kn c): |
| Kn (fun x a=>twins (H x a) (r x a) (k x a) (p x a) (i x a) (j x a) M (l x a) (n x a) (s x a) (c x a)):=by |
| have hg:=Prism.swapK hm hf ht hD M |
| have hi:=portK ((Kn.fix 3).add (hf.add (Kn.fix M))) |
| have hy:=orbitK 15 he hx hg; have hW:=orbitK 14 he hx hg |
| have hq:= (Kn.wash.comp ((Kn.fix (0:ℕ)).tuple ((Kn.fix 3).add ht))).tuple ((Kn.fix M).tuple ht) |
| have hC:Kn (fun x a=> bitV (detector (l x a) 0)):= (hu.tuple (hu.tuple (Kn.fix _))).tuple (Kn.fix ((6,0,false):ChoiceX)) |
| exact (h.tuple (hi.tuple ((hy.tuple hw).tuple hq))).tuple |
| ((Kn.fix _).tuple (hc.tuple ((Kn.fix _).tuple ((hW.tuple hw).tuple |
| (hf.cond_eq (Kn.fix 0) (Kn.fix 0) (orbitK 17 he hC hg)))))) |
| end |
| end Crest |
|
|
| namespace RowD |
| open Crest |
| variable (w:Wares) |
|
|
| def foreC (p:Crt): Scout:= |
| let q:=fence p |
| (q.1,q.2.1,q.2.2.1,false) |
| def school(p:Crt)(k:ℕ)(b:Bool):Scout:= ((stageQ p,(if b then stageQ p else (params p).2.1),k,max (greenY p) k),0,0,true) |
| def hinge (p:Crt)(u:ℕ):Scout:= |
| let k:=stageQ p |
| ((k,(params p).2.1,k,u),if origin p=2∨origin p=4 then 2 else 3,(countO w p)-1,true) |
| def coral (p:Crt)(k j:ℕ):Scout:=((stageQ p-1,(params p).2.1,k,max (greenY p) k),1,j,true) |
|
|
| variable {q w0 h:ℕ}(r:Rock q w0 h) |
| abbrev n:=r.n |
| def dock(x:Word)(c:Crt)(s:Fog):Hull:= HullT.tides r x c s.first0 (s.tick r.w,s.event) |
| abbrev skies(x:Word)(c:Crt)(s:Fog):Issue:= |
| Print.stepout (r.n x) (params c).2.1 (HullT.determine c s.first0) (s.tick r.w) s.event (dec (Age.env c)) |
| def startF(x:Word)(_:Crt)(s:Fog):Coin:= |
| let t:=WindY.shower r x (s.tick r.w) |
| if s.2.1 then t else Coin.neg t |
| def scaleB (x:Word)(c:Crt)(s:Fog):Coin:= Coin.mult (startF r x c s) |
| (Aqua.quo (r.n x) (greenY c) ((s.ray (greenY c)).1)) |
|
|
| def pickA(x:Word)(c:Crt)(s:Seed):Embellish:= |
| let f:=s.fog |
| let u:= dock r x c f |
| let k:=f.ray (greenY c) |
| let p:=f.budget (m c) |
| let y:= skies r x c f |
| let h:= scaleB r x c f |
| if f.first0 then |
| if origin c=0 then |
| let M:=r.w.p.M |
| if s.x=0 then twins u p s.y (coral c k.1 (k.2%M)) (k.2/M) (k.2%M) M (stageQ c-1) (r.n x) y h else bald |
| else if k.2=0 then |
| if s.x=0 then ordinary u true p s.y (school c k.1 false) y h else bald |
| else if k.2=1 then |
| Crest.company u p k.1 s.x s.y (hinge r.w c (stageQ c)) (school c k.1 true) |
| y (Coin.mult h (Aqua.rawcoins (r.n x) (stageQ c))) |
| else if s.x=0 then |
| ordinary u true p s.y (hinge r.w c (max (greenY c) (stageQ c))) y (Coin.neg h) |
| else bald |
| else if s.x=0 then ordinary u false p s.y (foreC c) y (Coin.mult (startF r x c f) Aqua.zet) else bald |
|
|
| section |
| variable {α}[Wire α]{b:PT α Crt}{f:PT α Fog}{p:PT α Seed}{j i n:PT α ℕ} |
| lemma chartK(h:Kn b)(e:Kn f):(Kn (fun x a=>dock r x (b x a) (f x a))) := |
| HullT.tideK r h e.left.left ((((Kn.fix r.w.ell).times e.left.right.right.right)).tuple e.right.right) |
| lemma skiesK(h:Kn b)(e:Kn f):Kn (fun x a=>skies r x (b x a) (f x a)) := |
| let k:=h.right.right.left.left.right |
| Print.stepK r.nKn k.left (e.left.left.cond k.right.left k.right.right) |
| ((Kn.fix _).times e.left.right.right.right) e.right.right (Kn.unpack.comp h.right.right.right) |
| lemma startK(_:Kn b)(e:Kn f):Kn (fun x a=> startF r x (b x a) (f x a)) := |
| let k:=WindY.showerK r ((Kn.fix _).times e.left.right.right.right) |
| e.right.left.cond k (Coin.negK k) |
| lemma scaleBK (h:Kn b)(e:Kn f):Kn (fun x a=> scaleB r x (b x a) (f x a)) := |
| Coin.multK (startK r h e) (Aqua.quoK r.nKn h.right.right.left.left.right.right.left |
| (Garden.Plot.fogK h e).left) |
| lemma cal (h:Kn b):Kn (fun x a=> foreC (b x a)):= |
| let e:= h.right.right.left |
| e.left.tuple (e.right.left.tuple (e.right.right.left.tuple (Kn.fix false))) |
| lemma skol (h:Kn b)(hp:Kn i)(g:Bool):Kn (fun x a=>school (b x a) (i x a) g):=by |
| have he:=h.right.right.left.left |
| have hf:=hp.tuple (Aqua.largeK he.right.right.left hp) |
| cases g |
| · exact (he.left.tuple (he.right.left.tuple hf)).tuple (Kn.fix _) |
| exact (he.left.tuple (he.left.tuple hf)).tuple (Kn.fix _) |
| lemma canK (h:Kn b)(hp:Kn i): Kn (fun x a=> hinge w (b x a) (i x a)):=by |
| have he:=h.right.right.left |
| have hg:= he.left.left |
| have hf:= he.right.left |
| have hz:= (hf.cond_eq (Kn.fix 1) (Kn.fix w.p.T) he.right.right.left).pred |
| have hk:Kn (fun x a=> (hinge w (b x a) (i x a)).2.1):=by |
| convert hf.cond_eq (Kn.fix 2) (Kn.fix (α:=α) (2:ℕ)) |
| (hf.cond_eq (Kn.fix 4) (Kn.fix (2:ℕ)) (Kn.fix (3:ℕ))) using 1 |
| ext x a; unfold hinge; grind |
| exact (hg.tuple (he.left.right.left.tuple (hg.tuple hp))).tuple (hk.tuple (hz.tuple (Kn.fix true))) |
| lemma coalK (h:Kn b)(he:Kn i)(hp:Kn j): Kn (fun x a=> coral (b x a) (i x a) (j x a)) := |
| let u:=h.right.right.left.left |
| (u.left.pred.tuple (u.right.left.tuple (he.tuple (Aqua.largeK u.right.right.left he)))).tuple |
| ((Kn.fix 1).tuple (hp.tuple (Kn.fix _))) |
| lemma pollen (h:Kn b)(e:Kn p):Kn (fun x a=> pickA r x (b x a) (p x a)):= by |
| have hf:= e.right |
| have hp:=h.right.right.left.left |
| have ht:=hp.left; have hz:=hf.left.left |
| have hh:=e.left.right |
| have hJ:=chartK r h hf |
| have hv:= h.right.left.left.sub hf.left.right.right.right |
| have hW:=hf.right.left.cond hv.pred.succ hv.pred |
| have he:= Garden.Plot.fogK h hf |
| have hs:= skiesK r h hf |
| have hN:= scaleBK r h hf |
| let n:=r.nKn (α:=α) |
| let M:= Kn.fix (α:=α) r.w.p.M |
| let z(f:PT α Embellish)(hp:Kn f):= hh.left.cond_eq (Kn.fix 0) hp (Kn.fix bald) |
| exact hz.cond |
| (h.right.right.left.right.left.cond_eq (Kn.fix 0) |
| (z _ (Crest.twinK hJ hW hh.right (coalK h he.left (he.right.mod M)) |
| (he.right.div M) (he.right.mod M) r.w.p.M ht.pred n hs hN)) |
| (he.right.cond_eq (Kn.fix 0) |
| (z _ (Crest.ordinaryK hW (skol h he.left false) hs hh.right hJ hN true)) |
| (he.right.cond_eq (Kn.fix 1) (Crest.companyK hW (canK r.w h ht) (skol h he.left true) hs |
| hh.right hh.left hJ (Coin.multK hN (Aqua.rawK n ht)) he.left) |
| (z _ (Crest.ordinaryK hW (canK r.w h (Aqua.largeK hp.right.right.left ht)) hs hh.right hJ (Coin.negK hN) true))))) |
| (z _ (Crest.ordinaryK hW (cal h) hs hh.right hJ (Coin.multK (startK r h hf) (Kn.fix _)) false)) |
| end |
|
|
| end RowD |
| end Blade |
| end |
| end ExactDerandomization.Spring |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Spring |
| 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 Glass Glass.Rod Rain |
| open Cambria Cambria.Wear Garden Blade Cambria.BadgeX Terrain |
| noncomputable section |
| open scoped Classical |
| variable {q w h:ℕ} |
|
|
| namespace Lily |
| variable (r:Rock q w h) |
| abbrev defaultH (x:Word)(c:Crt):Hull:= HullT.tides r x c true (0,0) |
| def recruit (x:Word)(s: Garden.Lead):Embellish:= |
| let w:= s.1 |
| let p:=s.2 |
| let h:=defaultH r x w |
| if p.1.1=0 then Crest.bronze w h p.x |
| else if p.1.1=1 then Crest.newelf (r.n x) (greenY w) h p.x |
| else RowD.pickA r x w p |
|
|
| def arms (x:Word)(p:Pan):Embellish:= |
| if Garden.clean r.w p then recruit r x (dec p.1,dec p.2) else bald |
| def wraps (x:Word)(p:Pan):GridY:=(p.1,arms r x p) |
| def pose0 (x:Word)(a:Mold.Croft):Aide:= |
| (arms r x (pointer a.1 1,a.2.1)).1.priceC a.2.2 |
| lemma armsK:Kn (arms r) := by |
| have h:= Kn.first (α:=ℕ) (β:=ℕ); have e:= Kn.next (α:=ℕ) (β:=ℕ) |
| have hs:=(Kn.unpack (α:=Crt)).comp h |
| have he:=(Kn.unpack (α:=Seed)).comp e |
| have hf:=HullT.tideK r hs (Kn.fix true) (Kn.fix ((0,0):Rill.History)) |
| have hp:=he.left.left; have hz:=he.left.right.left |
| exact (Garden.Plot.basin _).cond |
| (hp.cond_eq (Kn.fix 0) (Crest.bronzeK hs hf hz) |
| (hp.cond_eq (Kn.fix 1) (Crest.neoK r.nKn hs.right.right.left.left.right.right.left hf hz) |
| (RowD.pollen r hs he))) (Kn.fix _) |
| attribute [local irreducible] arms RowD.pickA |
| def poseX:Pose:= by |
| have he:= (Kn.first (α:=ℕ) (β:=Rill.History)) |
| let k:= Kn.wash.comp ((Kn.fix (1:ℕ)).tuple (((Kn.unpack (α:=Crt)).comp he).right)) |
| have h:= armsK r |
| exact ⟨_,Surf.Prep.aideK (h.comp (k.tuple Kn.next.left)).left Kn.next.right⟩ |
| set_option maxHeartbeats 200000 in |
| lemma goalF (x a): (poseX r).f x a=pose0 r x a:=rfl |
|
|
| def bay (x:Word)(a:ℕ):ℕ:= |
| let p:= Reed.V x a |
| enc (wraps r x (p.1,p.2.1)) |
| lemma bayK:Kn (bay r):= |
| Kn.wash.comp ((Kn.first.tuple (armsK r)).comp (Reed.VK.left.tuple Reed.VK.right.left)) |
| abbrev liftq (r:Rock q w h) := Fret.Seats.transformed (Cub.mk (bay r) (bayK r)) |
| def foreP (v: Tags)(p:MintV)(base:Cog) : ℕ → Cog |
| | 1=> liftq r (grainq p (Wear.shelf (knob r v)) r (schedule r v) true) |
| | 2=> liftq r (grainq p (Wear.shelf (knob r v)) r (schedule r v) false) |
| | 5=>base |
| | _=> liftq r ((hub r).garden (schedule r v)) |
| private lemma foreP_choice (v:Tags) (p:MintV) (base:Cog) (b:Bool): |
| foreP r v p base (if b then 1 else 2) = |
| liftq r (grainq p (Wear.shelf (knob r v)) r (schedule r v) b) := by |
| cases b <;> rfl |
| |
| abbrev prog (v:Tags)(p:MintV)(base:Cog) := Studio.arrange (foreP r v p base) 5 |
| attribute [local irreducible] bay Lily.poseX |
| attribute [local irreducible] Lily.recruit Arena.Gate.garden Wear.coast |
|
|
| namespace Service |
| open Cambria.Rime Rime.Nest Rime.Nest.Good |
| open Fret.Seats |
| variable {u:Line (q:=q) (w:=w) (h:=h)} {p:MintV} |
| structure Fits (s:Nest u) (v:Fabric u) (i j:ℕ) :Prop where |
| good:s.Good |
| cageX:s.ray.cage=(v.α s.t i) |
| book : wraps u.r u.x (s.ray.src,j)=(s.a,s.ray.t,s.diploma) |
| yarn : u.s.pave=poseX u.r |
| namespace Fits |
| set_option maxHeartbeats 200000 |
| variable {s:Nest u}{v:Fabric u}{i j}(h0:Fits s v i j) |
| include h0 |
| lemma stow : bay u.r u.x ((Studio.stk u s.a s.ray.x j).info)=s.v:= by |
| unfold bay Studio.stk Reed.film info panelx Reed.V |
| dsimp only; rw [dec_round] |
| rw [h0.good.scores] |
| exact congrArg enc h0.book |
| lemma traced0 : (arms u.r u.x (s.a,j)).1=s.ray.t:=by |
| have he:= congrArg (fun a:GridY=>a.2.1) h0.book |
| exact he |
|
|
| abbrev prS (s:Nest u)(j:ℕ):Seats:=Studio.stk u s.a s.ray.x j |
| lemma cupF {qB t c a b}(h:s.home.hear t c qB a b):(prS s j).hear t c (liftq u.r qB) a b:=by |
| have hu:(panelx (prS s j) s.v).hear t c qB a b:=h |
| apply importD (s:=prS s j) ⟨_,bayK u.r⟩ _ hu |
| exact h0.stow |
| lemma cupG {qB t c a b}(h:s.home.band c t a qB b):(prS s j).band c t a (liftq u.r qB) b:=by |
| have hu:(panelx (prS s j) s.v).band c t a qB b:=h |
| apply transportD (s:=prS s j) ⟨_,bayK u.r⟩ _ hu |
| exact h0.stow |
| lemma engrave(k): offer u.s.pave u.x (stem s.ray.cage.visN j k)=s.ray.t.priceC k:=by |
| have hs:s.ray.cage.visN=v.c 2 i:= congrArg CageQ.visN h0.cageX |
| have he:(uphold s.ray.cage.visN).1=2:=by rw [hs,Stone.roleR] |
| unfold offer; rw [ite_eq_left (show (uphold s.ray.cage.visN).1=2 from he),h0.yarn,goalF]; unfold pose0 |
| have hf:pointer s.ray.cage.visN 1=s.a:=by |
| rw [hs,Stone.pointing] |
| exact congrArg CageQ.dataN h0.cageX |>.symm |
| simp only [] |
|
|
| rw [hf] |
| rw [h0.traced0] |
|
|
| lemma supplies (base) (hr:Studio.Parcel u s.a (Lily.prog u.r u.v s.t base))(hv:u.smallQ s.a j): |
| u.D.swears (post s.a 0 j 0) s.ray.x (title s):=by |
| let S:= Studio.stk u s.a s.ray.x j |
| have hx:S.rite (C0 s) (foreP u.r u.v s.t base 0) (title s):= by |
| have he:=h0.cupF (qB:=(hub u.r).garden u.D.s) h0.good.home0 |
| rw [foreP] <;> first| exact he | decide |
| have hs:=Era.billed u.r |
| have ht := (Wear.Paper.eras s.t u.r u.D.s (krod u) true (title s)).1 |
| exact Studio.echoTicket h0.good.primary (by omega: (0:ℕ) ≤ 5) (by omega) hv |
| (le_trans (le_trans (by omega) hs.1) ht) h0.good.large0 hx hr |
| lemma portraits(base) (hr:Studio.Parcel u s.a (Lily.prog u.r u.v s.t base))(hv:u.smallQ s.a j): |
| u.eye.Flora u.torch.p s.ray.cage.visN j s.ray.x s.ray.outR:= by |
| apply h0.good.grip.paths hv _ (h0.engrave _) |
| rw [show s.ray.cage.tagop=0 from congrArg CageQ.tagop h0.cageX] |
| exact h0.supplies base hr hv |
| private lemma beams_band (base) (b:Bool) (X:ℝ) (hx:gross s b X): |
| (Studio.stk u s.a s.ray.x j).band (C0 s) s.H s.t.inputH |
| (foreP u.r u.v s.t base (if b then 1 else 2)) X:=by |
| have hs : u.D.s = schedule u.r u.v := rfl |
| rw [foreP_choice, ← hs] |
| exact h0.cupG (qB:=grainq s.t (krod u) u.r u.D.s b) hx |
|
|
| lemma beams (base) (hr:Studio.Parcel u s.a (Lily.prog u.r u.v s.t base))(hv:u.smallQ s.a j) |
| (b:Bool)(X:ℝ)(hx:gross s b X): |
| u.D.Voice s.a s.ray.x (hole (if b then 1 else 2) j) (u.D.high s.a) (s.t.inputH*u.D.D s.a) X:=by |
| let S:= Studio.stk u s.a s.ray.x j |
| let k:= if b then 1 else 2 |
| have hx': S.band (C0 s) s.H s.t.inputH (foreP u.r u.v s.t base k) X:= |
| h0.beams_band base b X hx |
| have hs:=Era.billed u.r |
| have ht := (Wear.Paper.eras s.t u.r u.D.s (krod u) b (title s)).1 |
| have he:k ≤ 5:=by unfold k; split<;>omega |
| exact Studio.scoreTicket (u := u) (a := s.a) (x := s.ray.x) (i := j) (j := s.t.inputH) |
| (c := C0 s) (o := k) (m := 5) (H := s.H) (f := foreP u.r u.v s.t base) |
| h0.good.primary he (by omega) hv |
| (le_trans (le_trans (by omega) hs.1) ht) h0.good.large0 le_rfl hx' hr |
| end Fits |
| end Service |
| end Lily |
| end |
| end ExactDerandomization.Spring |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Spring |
| 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 Glass Glass.Rod Rain |
| open Cambria Cambria.Wear Garden Blade Terrain Terrain.Bank BadgeX |
| noncomputable section |
| open scoped Classical |
| variable {q w h:ℕ} {u:Line (q:=q) (w:=w) (h:=h)} |
| namespace Fen |
| variable (w:Wares) |
| lemma Kpos:0<w.p.K:=by |
| have hs:=w.p.KOK |
| have hx:0 < (w.p.T+1:ℝ)/eta delta:=by unfold eta delta Hie.A; positivity |
| by_contra! hn; rw [Nat.eq_zero_of_le_zero hn] at hs; push_cast at hs; nlinarith |
| |
| variable (v:Fabric u) |
| abbrev owner(a:Fabric u)(i:ℕ):Crt:=kit 1 (a.m,i) (bitR a.t) (enc (Print.issued a.dye)) |
| lemma heir (i):enc (owner v i)=v.c 1 i:=rfl |
| lemma therein (i): (dec (v.c 1 i) : Crt)=owner v i:=by rw [← heir,Wire.eq] |
| abbrev year(a:Fabric u): Est.Stair:=a.t.stair u.plotM a.m |
| abbrev ashes (a:Fabric u)(b:Bool):Est.Flame u.n:= |
| if b then a.t.start u.plotM a.roll a.m else a.t.companion u.plotM a.roll |
| abbrev gridR (a:Fabric u)(b:Bool): Axis:= |
| if b then a.t.plan u.plotM else (a.t.plan u.plotM).narrowed a.t.t |
| lemma force (b:Bool)(j:ℕ):foreground u.w0 (owner v j) b=(ashes v b).rays :=by |
| let a:=v.t |
| cases b |
| · change (if a.main=true∧(shaped a.tag).1≠4 then {(a.a,0)} else ∅)= (if a.two then {(a.a,0)} else ∅) |
| unfold Quest.two |
| cases he:a.tag <;> simp [Kind.paired, shaped] |
| next b i=> cases b <;> simp |
| change _= (a.start u.plotM v.roll v.m).rays |
| unfold Quest.start |
| let r:=owner v j |
| have hp: origin r=(shaped a.tag).1:=rfl |
| have hh: greenY r=a.a:=rfl |
| have ht: Garden.stageQ r=a.i:=rfl |
| have hn:m r=v.m:=rfl |
| have hW:(fence r).2.2.1=(shaped a.tag).2:=rfl |
| change foreground u.w0 r true=_ |
| unfold foreground countO asker |
| rw [hp,hh,ht,hn,hW] |
| cases hq:a.tag |
| · cases he:a.i with |
| | zero=> simp [shaped] |
| | succ i=> simp only [Quest.agency,Quest.fleet,Quest.tray,shaped, Nat.add_sub_cancel, |
| ite_true, ite_eq_right (by omega:i+1≠0)] |
| rfl |
| · simp [shaped,Quest.pipe,Quest.company,Quest.tray]; rfl |
| · next b k=> cases b <;> simp [shaped,Quest.pipe,Quest.company,Quest.tray] <;> rfl |
| simp [shaped,Quest.pipe,Quest.company,Quest.tray]; rfl |
| lemma fuel (_:ℕ)(z:Cambria.Hull):z.1=z.1:=rfl |
| lemma quietox {i _ j _ _:ℕ}{_:Fog}(h:retired u.w0 (owner v i) (Seed.old true j)): |
| Age.g (owner v i) ≠0∧ j < capacity 2 u.w0.p.K (Age.L v.m) (i-1):= |
| ⟨h.2.1,h.2.2⟩ |
|
|
| namespace GardenV |
| lemma oldcap {w:Wares} {d i:ℕ}(hd:0<d)(b:Bool)(hp:lb (enc i) ≤ passport w*d): |
| Pass.sized (Seed.old b i) (Pass.reserve w) d:= by |
| let c:=passport w; have hc:50 ≤ c:=by unfold c passport; omega |
| have ht (b:Bool) : Pass.sized b c d:=Pass.boo b _ _ (by omega) hd |
| have he(a:ℕ)(h:a ≤ 1):Pass.sized a c d:=by |
| apply Pass.left _ _ _ (Pass.little _ d hd) |
| omega |
| let p:Fog:= ((false,(true,0),0,0),false,0) |
| have hP: Pass.sized p (4*(4*(4*(4*c)))) d:=by |
| have h1:Pass.sized ((true,(0:ℕ)): Rain.Crack) (4*c) d:=Pass.pair hd (by omega) (ht _) (he 0 (by omega)) |
| have h2:Pass.sized (((0:ℕ),0):Rill.History) (4*c) d:=Pass.pair hd (by omega) (he 0 (by omega)) (he 0 (by omega)) |
| have h3:= Pass.pair hd (by omega) h1 h2 |
| have h5:= Pass.pair hd (by omega) (ht false) (he 0 (by omega)) |
| exact Pass.pair hd (by omega) (Pass.pair hd (by omega) (Pass.left Bool.false _ _ (ht Bool.false) _ (by omega)) h3) |
| (Pass.left _ _ _ h5 _ (by omega)) |
| have h1 := Pass.pair hd (by omega:2 ≤ c) (show Pass.sized i c d from hp) (he 0 (by omega)) |
| let k:ℕ:=if b then 0 else 1 |
| have h3:k ≤ 1:=by unfold k; split<;>omega |
| have h2:=Pass.pair hd (by omega) |
| (Pass.left k _ _ (he k h3) (4*c) (by omega)) h1 |
| exact Pass.left _ _ _ (Pass.pair hd (by omega) (Pass.left _ _ _ h2 _ (by omega)) hP) _ |
| (by unfold Pass.reserve; change _ ≤ _*c; omega) |
| lemma forestLen {w:Wares}{a:Crt}{b:Bool}{r:Ray}(h:r∈foreground w a b): |
| r.2 ≤ w.p.M^2+2*w.p.M+2:=by |
| unfold foreground at h |
| split at h |
| · split at h |
| · split at h |
| · simp only [notMem_empty] at h |
| have ht:= mem_range.1 (mem_product.mp h).2; nlinarith |
| simp only [mem_union,mem_product,mem_range] at h; grind |
| split at h |
| · simp only [mem_singleton] at h; rw [h]; dsimp only; omega |
| simp only [notMem_empty] at h |
| |
| set_option maxRecDepth 6000 in |
| lemma windowN {i:ℕ}(hi:i<Age.L v.m){p:MintV}(he:Green u.r p){s:Seed}(hg:ace u.w0 (owner v i) s): |
| enc s < p.rangeN (gap v.m i):=by |
| let d:=gap v.m i; let c:=owner v i |
| have hd:1 ≤ d:=gap_pos .. |
| apply lt_of_lt_of_le (below _) (Nat.pow_le_pow_right (by omega) ?_) |
| change lb _ ≤ p.vol*d |
| apply le_trans _ (Nat.mul_le_mul_right d ((le_trans (show Pass.reserve u.r.w ≤ 4+Pass.reserve u.r.w by omega) he.power))) |
| change Pass.sized s _ d |
| rcases hg with h|h|h |
| · have hc:s=Seed.along s.2 s.x s.y:=h.1 |
| exact Eq.mp (congrArg (fun q=>Pass.sized q (Pass.reserve u.w0) d) hc.symm) |
| (Pass.lengthC u.w0 (s:=year v) rfl hi (fun q _=>forestLen ‹_›) |
| h.2.2.2 h.2.1.le h.2.2.1.le) |
| · obtain ⟨hc,hj,hq⟩:=h |
| apply Eq.mp (congrArg (fun q=>Pass.sized q (Pass.reserve u.w0) d) hc.symm) (oldcap (w:=u.w0) (i:=s.x) hd true ?_) |
| have hk : (i-1)+1=i:=by change i≠0 at hj; omega |
| change s.x < capacity 2 u.w0.p.K (Age.L v.m) _ at hq |
| rw [Green.capacityE] at hq |
| have hu:gap v.m (Age.g (owner v i)-1)=2*d:=by |
| apply Eq.trans (gap_step (i:=i-1) (by omega)) _ |
| rw [hk] |
| rw [hu] at hq |
| apply le_trans (modest hq (by unfold CarryE cexpo fexpo; nlinarith)) |
| have ht:2*CarryE u.w0 ≤ passport u.w0:=by unfold passport; omega |
| nlinarith |
| obtain ⟨hc,-,-,-,hj⟩:=h |
| apply Eq.mp (congrArg (fun q=>Pass.sized q (Pass.reserve u.w0) d) hc.symm) (oldcap (w:=u.w0) (i:=s.x) hd false ?_) |
| have hn:= lb_le_inc s.x |
| change lb s.x ≤ _ |
| have hp:10 ≤ passport u.w0:=by unfold passport;omega |
| nlinarith |
| end GardenV |
| |
| open Census |
| abbrev R:=Census.Arc |
| abbrev area(v:Fabric u)(b:Bool)(i:ℕ):Finset Arc:= tracks (year v) (ashes v b).rays i |
| def chenille (b:Bool)(z:Arc×ℕ×ℕ):Seed:= Seed.along (drops (year v) b z.1) z.2.1 z.2.2 |
| def fanD (i:ℕ)(b:Bool):Finset (Arc×ℕ×ℕ):= area v b i ×ˢ ((range v.Rslots)×ˢ(range v.Rslots)) |
|
|
| lemma sauna {b:Bool}{i:ℕ}{z:Arc×ℕ×ℕ}(hz:z∈fanD v i b): |
| atmos u.w0 (owner v i) (chenille v b z):=by |
| obtain ⟨hx,hb,hc⟩:= show z.1∈area v b i∧ z.2.1< u.w0.p.K ∧ z.2.2<u.w0.p.K from by simpa [fanD] using hz |
| have hp : (chenille v b z).fog.first0=b:=rfl |
| refine ⟨rfl,hb,hc,?_⟩ |
| rw [hp,Fen.force] |
| exact (grange (year v) rfl b hx).1 |
| lemma skyfell {s:Seed}{i:ℕ}(b:Bool) : |
| s∈ (fanD v i b).image (chenille v b) ↔ atmos u.w0 (owner v i) s∧ s.fog.first0=b:=by |
| constructor |
| · intro h; obtain ⟨v,h1,rfl⟩:=mem_image.1 h |
| exact ⟨sauna _ h1,rfl⟩ |
| rintro ⟨h,rfl⟩ |
| let a:=greenY (owner v i) |
| let M:=m (owner v i) |
| let t:=s.fog |
| let r:Arc:=(t.ray a,t.slackM M,t.2) |
| let w:Arc×ℕ×ℕ:=(r,s.x,s.y) |
| obtain ⟨he,hh,hc,hp⟩:=h |
| rw [Fen.force] at hp |
| have hg : t.habitat u.w0 (year v).key.a (year v).M i (ashes v t.first0).rays:=hp |
| obtain ⟨hx,hA,hW⟩:= Fog.totally rfl hg |
| have hf:r∈area v t.first0 i:=by |
| refine (pat ..).2 ⟨hx,hA,?_⟩ |
| have he:t.event<Print.rad^(u.w0.ell*t.sig):= hg.2.2.2.2 |
| change t.event<Print.rad^(u.w0.ell*_); change _^ (u.w0.ell * t.sig)>t.event at he |
| have hk : (year v).slack r.2.1=t.sig:=hp.2.2.1 |
| rwa [hk] |
| refine mem_image.2 ⟨w,mem_product.2 ⟨hf,mem_product.2 ⟨mem_range.2 hh,mem_range.2 hc⟩⟩,?_⟩ |
| change Seed.along _ _ _=s |
| rw [show drops (year v) s.fog.first0 w.1=t from hW]; exact he.symm |
| lemma meadow (b:Bool)(i:ℕ):Set.InjOn (chenille v b) ↑(fanD v i b):=by |
| intro x hx y hy he |
| obtain ⟨hf,hv,hq⟩:=Seed.along_inj.1 he |
| exact Prod.ext ((disjoint0 (w:=u.w0) (year v) rfl b _ i) (mem_product.1 hx).1 (mem_product.1 hy).1 hf) (Prod.ext hv hq) |
| end Fen |
|
|
| end |
| end ExactDerandomization.Spring |
|
|
| end |
|
|
| end OAI |
|
|
