| import OAI.Computability.Logspace.EstimatorInstructions |
|
|
| namespace OAI |
|
|
| /-! |
| The finite estimator program and its instruction-level resource contracts. |
|
|
| From OpenAI, *Exact Derandomization of Logarithmic Space: L = RL = BPL*. |
| -/ |
|
|
| set_option autoImplicit true |
|
|
| section |
|
|
| namespace ExactDerandomization.SiteX |
| open Counter Relay Rill Fret Chime Finset Grain Net Hie Est Analysis Stage Glass |
| open Helix Helix.Foil Helix.Age Helix.Moon Helix.Night Helix.Mold Helix.Orbit Scheme |
| noncomputable section |
|
|
| variable {q w h:ℕ} |
|
|
| structure Line where |
| r:Rock q w h |
| v:Tags |
| s:Stash |
| x:Word |
| namespace Line |
|
|
| variable (u:Line (q:=q) (w:=w) (h:=h)) |
| abbrev prog:=woven u.r u.v u.s |
| abbrev D:=stageC u.r u.v u.x u.prog |
| abbrev eye:=field u.r u.v u.x u.prog |
| abbrev torch:= Helix.Torch.harp u.r u.v (coneX u.r u.s.pave) |
| abbrev wick0:= wick u.r u.v u.x u.prog |
| abbrev n:= u.r.n u.x |
| abbrev w0 :=u.r.w |
| abbrev B := u.r.B u.x |
| abbrev m:=u.r.matter0 u.x |
| abbrev plotM:= u.m.s |
| abbrev limitM:= u.w0.top u.B |
|
|
| lemma poss (s:Pool u.n) : Print.publish u.n (enc (Print.issued s))=true:= |
| (mem_filter.1 (Print.entry _)).2 |
| def clr (a:Scout)(m p i:ℕ) (x:Pool u.n): ℕ:= |
| enc (kit p (m,i) a (enc (Print.issued x))) |
| def rowL (a:Quest):= u.clr (bitR a) |
| def vecL (v:Peek):=u.clr (bitV v) |
|
|
| structure Chart : Prop where |
| ok : ∃ p:u.w0.Proof, u.m.ready p |
| slopeX : max 6 (10*u.eye.e) ≤ u.v.slope |
|
|
| namespace Chart |
| variable {u:Line (q:=q) (w:=w) (h:=h)}(h0:u.Chart) |
| include h0 |
| lemma sc : u.plotM.SetUp:=by obtain ⟨p,h⟩:=h0.ok; exact u.m.lineup h |
| lemma above6 :6 ≤ u.v.slope:=(le_max_left ..).trans h0.slopeX |
| lemma draft {a:ℕ}(hp:licensed u.r u.x a) : u.D.Suite a:= dawn u.r u.v u.x u.prog _ hp |
| ((by omega:2 ≤ 6).trans h0.above6) |
| lemma rent {a}(he:u.D.active a) : u.D.Suite a:= h0.draft ((by classical exact of_decide_eq_true he)) |
| lemma e0 : u.D.Suite 0:= h0.draft (Or.inl rfl) |
| omit h0 in |
| lemma auth(a): u.D.active a↔ licensed u.r u.x a:= by classical exact decide_eq_true_iff |
| omit h0 in |
| lemma cred (c:Scout)(p s a:ℕ)(x:Pool u.n) : |
| u.D.active (u.clr c p s a x) ↔ |
| permit u.w0 u.B u.n (kit s (p,a) c (enc (Print.issued x))):=by |
| rw [(auth (u := u))]; simp only [licensed,clr, Age.cpos,dec_round,and_true,false_or] |
| omit h0 in |
| lemma courseR {p:Quest}{s a j:ℕ} (x:Pool u.n):u.D.active (u.rowL p s a j x)↔ |
| s ≤ u.limitM ∧ j<Age.Period s a∧rowUnit u.w0 a s (bitR p)∧p.ready u.plotM s:=by |
| unfold rowL; rw [(cred (u := u))]; unfold permit |
| have he:¬vecUnit u.w0 a s (bitR p):= fun hv=> solely (rightR p) hv.1 |
| have hp : testR u.w0 s u.B (roof u.r u.x) (bitR p) ↔ p.ready u.plotM s:=by |
| unfold testR; rw [recovery]; rfl |
| simp only [Age.g,Age.styx,Age.env,u.poss,hp,he,false_and,true_and,or_false] |
| |
| omit h0 in |
| lemma courseV {p:Peek}{s a j:ℕ} (x:Pool u.n):u.D.active (u.vecL p s a j x)↔ |
| s ≤ u.limitM ∧ j<Age.Period s a∧vecUnit u.w0 a s (bitV p)∧p.ready u.plotM s:=by |
| unfold vecL; rw [(cred (u := u))]; unfold permit |
| have he:¬rowUnit u.w0 a s (bitV p):= fun hv=> solely hv.1 (rightV p) |
| have hp : testV u.w0 s u.B (roof u.r u.x) (bitV p) ↔ p.ready u.plotM s:=by |
| unfold testV; rw [recovered]; cases p with | mk i u k => cases k <;> rfl |
| simp only [Age.g,Age.styx,Age.env,u.poss,hp,he,false_and,true_and,false_or] |
| |
| omit h0 in |
| lemma parse {a}(he:u.D.active a)(ha:a≠0): |
| (∃ p s i j x, a=u.rowL p s i j x) ∨ ∃ p s i j x,a=u.vecL p s i j x:=by |
| obtain ⟨hk,hA⟩:= (((auth (u := u)) _).1 he).resolve_left ha |
| generalize hm : (dec a:Crt)=v at * |
| obtain ⟨r,⟨c,e⟩,s,b⟩:=v |
| have hv :Print.publish u.n b=true:= hk.1 |
| change decide _=_ at hv |
| obtain ⟨hz,hB⟩:= of_decide_eq_true hv |
| obtain ⟨x,hi⟩:= Print.fill _ hz |
| have hh:enc (Print.issued x)=b:=by rw [hi,hB] |
| rw [←hA] |
| rcases hk.2.2.2 with ⟨hj,_⟩|⟨hj,_⟩ |
| · refine Or.inl ⟨claim s,c,r,e,x,?_⟩ |
| unfold rowL clr; rw [copyR (show faceR s from hj.1),hh] |
| refine Or.inr ⟨gaze s,c,r,e,x,?_⟩ |
| unfold vecL clr; rw [copyV (show faceV s from hj.1),hh] |
| omit h0 in |
| lemma walls {a q}(he:u.D.active a)(hp:unitK q=a): who q ≤ 17:=by |
| unfold who; rw [hp]; split |
| · omega |
| next ht=> |
| obtain ⟨hs,hv⟩:= (((auth (u := u)) a).1 he).resolve_left ht |
| apply Mold.sizeR _ u.x |
| rw [Mold.unitV,show enc (uphold a)=a from hv] |
| exact Or.inr ⟨hs,hv⟩ |
| omit h0 in |
| lemma assigned {a q b c v i j}(he:u.D.active a)(hp:unitK q=a) |
| (hx:Lot.Mane u.D.l c v b q (codeRank u.r u.v u.s (who q)) i j):Lot.Mane u.D.l c v b q u.prog i j:= |
| seated u.r u.v u.s hx ((walls (u := u)) he hp) |
|
|
| lemma chamber {a}(he:u.D.active a)(hu:u.D.Heard a)(hz:∀ b,u.D.active b→u.D.W b< u.D.W a→ |
| u.D.won b 0→u.wick0.Veil u.torch b): |
| u.wick0.Veil u.torch a:=by |
| let p:=u.torch; let r:=u.D; let s:=u.wick0 |
| have hS : Harp.Wick.Life p s:= Helix.Torch.life _ _ _ _ _ (by have:=h0.above6; omega) |
| have hD:= h0.rent he |
| apply Harp.Wick.Life.veiled hS hD hu hz |
| · exact (le_max_right ..).trans h0.slopeX |
| · intro i q hm hA |
| exact chask _ u.v u.x u.prog a i q he hA.under0 hm |
| intro i q h6 hB x y hy |
| have hh:unitK (Harp.quoteQ a i q)=a:=bellU .. |
| apply (Line.Chart.assigned (u := u)) he hh |
| have hb := hB.tokenpoint |
| change decide ((uphold a).1=2∨_) = true at hb |
| replace hb:=of_decide_eq_true hb |
| have hp0 :a≠0:=by |
| intro hp; subst a |
| |
| have H : (uphold 0).1=0:=rfl |
| grind |
| unfold who; rw [hh,ite_eq_right hp0] |
| unfold codeRank; rw [ite_eq_right (by omega),ite_eq_left hb]; exact hy |
| |
| end Chart |
| end Line |
| end |
| end ExactDerandomization.SiteX |
| |
| end |
| |
| section |
| |
| namespace ExactDerandomization.SiteX |
| open Counter Relay Rill Fret Chime Finset Grain Net Hie Est Analysis Stage Glass |
| open Helix Helix.Foil Helix.Age Helix.Moon Helix.Night Helix.Mold Helix.Orbit Scheme |
| open Dome Cone ConeX |
| noncomputable section |
| open scoped Classical |
| variable {q w h:ℕ} |
| namespace Line |
| variable (u:Line (q:=q) (w:=w) (h:=h)) |
| def smallQ (a i:ℕ):Prop:= u.eye.wideQ a i |
| lemma Launch {a}(he:u.D.active a) (i o t:ℕ)(hv:u.smallQ a i)(ho:o ≤ 32)(ht:t ≤ u.D.high a): |
| post a o i t ≤ u.D.F.limit:= Night.localC _ _ _ _ _ _ _ _ he hv ho ht |
| lemma Voices (a o i t:ℕ)(he:u.D.audible (post a o i t)): |
| taps (uphold a).1 o t ∧ u.smallQ a i:=by |
| have he:= of_decide_eq_true (show decide (entitled u.r u.v u.x (post a o i t))=true from he) |
| have hv:=he.2.2.2 |
| change taps (uphold (unitK (post a o i t))).1 (opt _) (date _)∧ lb _ ≤ _ at hv |
| rw [optionX,bellU,targetX,bellT] at hv; exact hv |
| lemma spokenC {a}(he:u.D.active a)(hz:a≠0)(o i t:ℕ)(hp:u.smallQ a i) |
| (hf:taps (uphold a).1 o t):u.D.audible (post a o i t):=by |
| refine decide_eq_true ?_ |
| change entitled _ u.v u.x _ |
| unfold entitled |
| dsimp only |
| rw [optionX,targetX,bellU,bellT] |
| exact ⟨hz,of_decide_eq_true he,rfl,hf,hp⟩ |
|
|
| /- reusable request-origin signature. all indices in the allotted range, incl holes. -/ |
| structure CageQ where |
| dataN:ℕ |
| visN:ℕ |
| tagop:ℕ |
| m:ℕ |
| namespace CageQ |
| variable (p:CageQ) |
| structure Front : Prop where |
| pos:u.D.active p.dataN |
| path:u.D.active p.visN |
| baseC: u.eye.e ≥4 |
| price:u.D.W p.dataN+u.D.D p.visN ≤ u.D.W p.visN |
| grain : u.D.D p.dataN=u.D.D p.visN |
| size0 : ∀ i<p.m,u.smallQ p.visN i |
| tip : (coneX u.r u.s.pave).ispath0.f u.x p.visN=true |
| ear0 : ∀ i,(coneX u.r u.s.pave).spur.f u.x (p.visN,i)=post p.dataN p.tagop i 0 |
| aloud :∀ i,u.smallQ p.visN i→u.D.audible (post p.dataN p.tagop i 0) |
|
|
| namespace Front |
| variable {u:Line (q:=q) (w:=w) (h:=h)}{p:CageQ}(he:Front u p) |
| include he |
| lemma awake {i} (hi:u.smallQ p.visN i):u.smallQ p.dataN i:=by |
| unfold smallQ ConeX.wideQ at *; change _ ≤ u.eye.e*u.D.D p.visN at hi |
| change _ ≤ u.eye.e*u.D.D p.dataN; rwa [he.grain] |
| lemma back0 {i} (hi:u.smallQ p.dataN i):u.smallQ p.visN i:=by |
| unfold smallQ ConeX.wideQ at *; change _ ≤ u.eye.e*u.D.D p.dataN at hi |
| change _ ≤ u.eye.e*u.D.D p.visN; rwa [← he.grain] |
| |
| lemma point0(h0:u.Chart) (i:ℕ)(hp:u.smallQ p.visN i): u.eye.BaseX u.torch.p p.visN i:=by |
| have hx:= h0.rent he.path |
| have ht:u.eye.ear u.torch.p p.visN i=post p.dataN p.tagop i 0:=he.ear0 i |
| refine ⟨he.baseC,⟨he.path,hx.well.1,hx.well.2,topo_hi _ _ _ _ _ he.path⟩,hp,?_,?_ ,?_ ,?_,he.tip⟩ |
| · exact highflex u.r u.x p.visN (of_decide_eq_true he.path) |
| · rw [ht]; exact he.aloud i hp |
| · rw [ht,bellT] |
| unfold ConeX.less; rw [ht,bellU]; exact he.price |
| |
| end Front |
| |
| structure Trace (x:ℕ)(tag wherep:ℕ→ℕ) :Prop where |
| next :∀ i,u.smallQ p.dataN i → u.D.swears (post p.dataN p.tagop i 0) x (tag i) |
| fits :∀ i,u.smallQ p.dataN i → u.smallQ p.visN (tag i) |
| maxm:∀ i,p.m ≤ i→ tag i=0 |
| road:∀ i,u.smallQ p.dataN i→u.eye.Flora u.torch.p p.visN i x |
| (if tag i=0 then none else some (tag i,wherep i)) |
|
|
| structure Offer (x:ℕ)(q k:ℕ)(F:ℕ→ℝ):Prop where |
| ready :∀ i,u.smallQ p.dataN i→ u.D.Voice p.dataN x (hole q i) (u.D.high p.dataN) (k*u.D.D p.dataN) (F i) |
| namespace Trace |
| variable {u:Line (q:=q) (w:=w) (h:=h)}{p:CageQ} |
| lemma distinct_path {x a f b g} (hA:Trace u p x a f)(hB:Trace u p x b g)(i:ℕ)(hk:u.smallQ p.dataN i): |
| a i=b i := (u.D.identity (hA.next _ hk)).symm.trans (u.D.identity (hB.next _ hk)) |
| lemma caseM {x a f} (hA:Trace u p x a f)(i:ℕ)(hi:a i≠0)(hk:u.smallQ p.dataN i): |
| u.eye.Pond u.torch.p p.visN i (a i) x (f i):=by |
| have ht:=hA.road i hk; rw [ite_eq_right hi] at ht; cases ht |
| assumption |
| lemma places {x a f} (hA:Trace u p x a f)(i:ℕ)(hi:a i≠0)(hk:u.smallQ p.dataN i): |
| f i∈ u.D.P := by cases hA.caseM i hi hk with |
| | leaf h0 _=> exact h0.hy |
| | born h0 _ _ _ _=> exact h0.hy |
| end Trace |
| end CageQ |
|
|
| /-- Cocoon. Universal micromoves on alpha 0. -/ |
| abbrev atom0 := Was.atom 0 |
| namespace Chart |
| variable {u:Line (q:=q) (w:=w) (h:=h)}(h0:u.Chart) |
| include h0 |
| lemma bootsBasic (i:ℕ):u.D.Streams (Was.atom i) (Was.stopped u.r u.x i):=by |
| apply Was.motion _ _ _ _ h0.above6 |
| intro b i j a m hp |
| have hl:unitK (Was.packB b i j)=0:=bellU .. |
| refine (Line.Chart.assigned (u := u)) h0.e0.stage hl ?_ |
| unfold who; rw [ite_eq_left hl] |
| exact hp |
| |
| omit h0 in |
| lemma voteRoot {i j} (hi:i ≤ u.v.bonus)(hj:j ≤ u.v.bonus):u.D.dual (Was.atom i) j:=by |
| apply decide_eq_true |
| unfold paired |
| simp only [cell,Scheme.inside,Was.atom,hole,dec_round,ite_true]; exact ⟨True.intro,hi,hj⟩ |
| lemma basic0 {i j x y:ℕ}(hm:Was.Flight u.r u.x i j x y)(hi:i ≤ u.v.bonus)(hj:j ≤ u.v.bonus): |
| u.D.curve (Was.atom i) j true x=some y:=by |
| have ht: u.n=u.D.peak:=rfl |
| rw [(h0.bootsBasic i).lines ((voteRoot (u := u)) hi hj) (show x∈ u.D.P from mem_range.2 |
| (Nat.lt_succ_of_le hm.1))] |
| exact (Was.travel u.r ..).2 hm |
|
|
| omit h0 in |
| lemma holdX {a i x m _ y:ℕ} |
| (_:x∈u.D.P)(hm:u.eye.ear u.torch.p a i=m) (he:u.D.swears m x y): |
| u.D.echo (u.eye.ear u.torch.p a i) x=y:= hm ▸ (u.D.identity he) |
| lemma Rope {p:CageQ}(ht:p.Front u) (i x h j a c m:ℕ) |
| (he:u.smallQ p.dataN i) (hr:u.smallQ p.visN h)(hs:h≠0)(hi:x∈u.D.P) |
| (hv:offer u.s.pave u.x (stem p.visN i h) =rope a j) |
| (hA : u.D.W 0+u.D.D p.visN ≤ u.D.W p.visN) |
| (hB:u.D.W a+u.D.D p.visN ≤ u.D.W p.visN) |
| (hD:u.D.D a ≤ 2*u.D.D p.visN)(hc:c∈u.D.P) |
| (hh:u.D.swears (post p.dataN p.tagop i 0) x h) |
| (ho:u.eye.Pond u.torch.p a j m x c): |
| u.eye.Flora u.torch.p p.visN i x (some (h,c)):=by |
| let z:=u.eye; let v:=u.torch.p; let L:=stem p.visN i h |
| have hQ : z.h0 v p.visN i h=Was.atom 0 ∧ z.f0 v p.visN i h=Was.atom 0 |
| ∧z.ip v p.visN i h=0 ∧v.shift.f z.D.x L=(1,0) ∧ z.b1 v p.visN i h=true ∧ |
| z.s1 v p.visN i h=a ∧ z.i1 v p.visN i h=j:=by |
| let w:=offer u.s.pave u.x L |
| change w.1.1=_∧ w.2.2.1=_∧w.1.2=_∧ w.2.2.2=_∧w.2.1.1=_∧w.2.1.2.1=_∧w.2.1.2.2=_ |
| have hr : w=rope a j:=hv; simp [hr,rope] |
| obtain ⟨hU,hV,hZ,hf,hj,ha,hW⟩:=hQ |
| have hp:=ht.point0 h0 i (ht.back0 he) |
| have hS(z:ℕ)(hz:z∈u.D.P):u.D.curve (Was.atom 0) 0 true z=some z:=by |
| apply h0.basic0 _ (Nat.zero_le _) (Nat.zero_le _) |
| have hc : z ≤ u.n:=by exact Nat.le_of_lt_succ (mem_range.1 hz) |
| simp [Was.Flight,hc] |
| have hY:z.Allow p.visN (Was.atom 0) 0:=by |
| refine ⟨(voteRoot (u := u)) (Nat.zero_le _) (Nat.zero_le _),?_⟩ |
| unfold Was.atom; rw [show cell (hole 0 0)=0 by simp [cell,hole]] |
| exact hA |
| apply Flora.wet |
| apply Pond.born (m:=x) (m':=c) ?_ hj ?_ ?_ (h':=m) ?_ |
| · have hg: c ≤ z.D.peak:=Nat.le_of_lt_succ (mem_range.1 hc) |
| refine ⟨hp,hs,?_,hr,?_,?_,?_,hi,hi,hc,hc,?_,?_,?_⟩ |
| · change z.D.echo (u.eye.ear _ _ _) _ = _ |
| rw [show u.eye.ear u.torch.p p.visN i=post p.dataN p.tagop i 0 from ht.ear0 i] |
| exact u.D.identity hh |
| · rw [hZ]; unfold wideQ; rw [lb_zero]; have hv:=hp.posX; have hs:=hp.lowp.2.1 |
| nlinarith |
| · rw [hZ,hU]; exact hY |
| · rw [hV]; exact hY |
| · rw [hZ,hU]; exact hS x hi |
| · rw [hV]; exact hS c hc |
| change min _ ((v.shift.f z.D.x L).1*c+(v.shift.f z.D.x L).2)=_ |
| rw [hf]; simp [hg] |
| · rw [ha]; exact hB |
| · rw [ha]; exact hD |
| rw [ha,hW]; exact ho |
| end Chart |
| end Line |
| end |
| end ExactDerandomization.SiteX |
| |
| end |
| |
| section |
| |
| namespace ExactDerandomization.SiteX |
| open Counter Relay Rill Fret Chime Finset Grain Net Hie Est Analysis Stage Glass |
| open Helix Helix.Foil Helix.Age Helix.Moon Helix.Night Helix.Mold Helix.Orbit Scheme |
| open Dome Cone ConeX Buf |
| noncomputable section |
| |
| /- Scalar prices determined before unfolding predecessor calls. -/ |
| structure MintV where |
| coin:ℕ |
| vol:ℕ |
| sealR:ℕ |
| low:ℕ |
| namespace MintV |
| def prism (p:MintV) := 20+2*p.coin |
| abbrev tokenH (p:MintV) := p.vol+p.prism |
| abbrev inputH (p:MintV) := 3*p.sealR |
| def rangeN (p:MintV)(d:ℕ):ℕ:=2^(p.vol*d) |
| abbrev roofX (p:MintV)(d:ℕ):ℝ:=massB p.sealR d |
|
|
| def shellQ(p:MintV)(m i:ℕ):ℝ:=p.roofX (if i=0 then 2*gap m 0 else gap m (i-1)) |
| lemma shore (p:MintV)(m i:ℕ): p.shellQ m (i+1)=p.roofX (gap m i):=by simp [shellQ] |
| lemma shorn (p:MintV)(m i:ℕ) (h:i<Age.L m): p.shellQ m i=p.roofX (2*gap m i):=by |
| cases i with |
| | zero=>rfl |
| | succ i=>simp only [p.shore,gap_step h] |
| def fine (p:MintV):Prop:=4 ≤ p.sealR ∧ p.tokenH ≤ p.sealR |
| lemma fluc (p:MintV){d:ℕ}(h:p.fine)(hp:1 ≤ d):16 ≤ p.roofX d:=by |
| have he: 4 ≤ p.sealR*d:=by have:=h.1; nlinarith |
| calc |
| (16:ℝ) ≤ 2^(4:ℕ):=by norm_num |
| _ ≤ _ := pow_le_pow_right₀ (by norm_num) he |
| lemma decor (p:MintV){m i:ℕ}(h:p.fine)(hi:i<Age.L m)(v:At.Pt) |
| (he: ht v ≤ massB p.tokenH (gap m i)): |
| ht v+p.shellQ m (i+1) ≤ p.shellQ m i:=by |
| let d:=gap m i |
| rw [p.shore,p.shorn m i hi] |
| have hp:= p.fluc h (d:=d) (gap_pos ..) |
| have hu:ht v ≤ p.roofX d:=he.trans (mass_mono h.2 _) |
| change ht v + p.roofX d ≤ p.roofX (2*d) |
| have hx:p.roofX (2*d)=p.roofX d*p.roofX d:=by unfold roofX massB; rw [←pow_add]; congr 1; ring |
| rw [hx]; nlinarith |
| end MintV |
| open MintV |
| variable {q w h:ℕ} |
|
|
| namespace Line |
| variable (u:Line (q:=q) (w:=w) (h:=h)) |
|
|
| @[simp] lemma rolff (a:Scout)(m c i:ℕ)(x:Pool u.n): |
| Age.D (u.clr a m c i x)=slackT m c i:= by unfold clr; rw [DI]; rfl |
| @[simp] lemma rolfe(a m c i x): Age.W (u.clr a m c i x)=weight m c i:=by unfold clr; rw [WI]; rfl |
| |
| structure Fabric where |
| t:Quest |
| m:ℕ |
| dye:Pool u.n |
| namespace Fabric |
| variable {u:Line (q:=q) (w:=w) (h:=h)} |
| variable (v:Fabric u) |
| abbrev roll:= rolls u.plotM v.m |
| abbrev frame := v.t.flame u.plotM v.roll v.m |
| abbrev c(i g:ℕ):= u.rowL v.t v.m i g v.dye |
| def activeR:=onQ u.w0.A0 v.m (v.t.key u.plotM)=true |
| abbrev world := v.frame.d |
| abbrev S0 := v.frame.src0 v.dye |
| abbrev S1 := v.frame.dst0 v.dye |
| abbrev S2 := v.frame.dst1 v.dye |
| abbrev marathon(x:ℕ): Buf.Run := v.frame.go v.dye x |
| lemma leg(x):(v.marathon x).L=Age.L v.m:=rfl |
| abbrev tagged(c:ℕ): Bool := decide (c ≤ 4) |
| abbrev govern := v.t.tag.narrow |
| def Good:= v.m ≤ u.limitM∧v.t.ready u.plotM v.m |
|
|
| lemma workR : v.activeR↔operateR u.w0 v.m (bitR v.t):=by |
| unfold operateR; rw [recovery]; unfold activeR onQ Quest.key; simp only [decide_eq_true_eq]; rfl |
| namespace Good |
| variable {v:Fabric u}(e:u.Chart)(hu:v.Good) |
| include e hu |
| lemma booked {a b:ℕ}(hi:b < Age.Period v.m a)(he:rowUnit u.w0 a v.m (bitR v.t)): |
| u.D.Suite (v.c a b):=e.rent (((Line.Chart.courseR (u := u)) v.dye).2 ⟨hu.1,hi,he,hu.2⟩) |
| lemma encs {i:ℕ}(hx:i∈ v.world.S):i< u.n:= mem_range.1 (e.sc.ids _ hu.2.1 hx) |
| lemma n0 {i:ℕ}(hx:i∈ v.S0):i∈u.D.P:= mem_range.2 ((encs e hu (mem_filter.1 hx).1).trans (by change u.n < u.n+1; omega)) |
| lemma n1 {i:ℕ}(hx:i∈ v.S1):i∈u.D.P:= mem_range.2 ((encs e hu (mem_filter.1 hx).1).trans (by change u.n < u.n+1; omega)) |
| end Good |
| |
| structure HistoryC (v:Fabric u)(p:MintV)(x i:ℕ) where |
| kap:ℕ→Bool |
| namespace HistoryC |
| variable {p:MintV}{x i:ℕ} |
| abbrev R (p:MintV)(v:Fabric u)(j:ℕ):ℝ:=p.roofX (gap v.m j) |
| abbrev actual (a:HistoryC v p x i)(j:ℕ):= (v.marathon x).actual (R p v) a.kap j |
| structure Compared (a:HistoryC v p x i) : Prop where |
| cooling : ∀ j < i,a.kap j=true →1 ≤ ((v.marathon x).pm j).U ((v.marathon x).shifted j (actual v a j)) |
| shield : ∀ j < i,∀ y∈ (v.marathon x).S, ht ((v.marathon x).inc j y) ≤ massB p.tokenH (gap v.m j) |
|
|
| lemma Compared.set {a:HistoryC v p x i}(h:Compared v a) (hi:i=Age.L v.m)(he:p.fine) |
| {θ C f z} (hp:At.TS θ C f) (hh:θ ≤ 1)(hc:C ≤ p.roofX 1)(hx:z∈(v.marathon x).S): |
| (actual v a i).val (v.marathon x).S (v.marathon x).K f z= |
| ((v.marathon x).mid i).val (v.marathon x).S (v.marathon x).K f z := by |
| unfold actual |
| rw [← v.leg x] at hi |
| subst i |
| apply Run.clamped _ hp hh (p.shellQ v.m) |
| · intro j hj |
| let d:= if j=0 then 2*gap v.m 0 else gap v.m (j-1) |
| have hx:1 ≤ d:=by |
| unfold d; split; have :=gap_pos v.m 0; omega |
| exact gap_pos .. |
| refine ⟨le_trans hc ?_,?_⟩ |
| · change (2:ℝ)^_ ≤ (2:ℝ)^(p.sealR*d); gcongr; norm_num |
| change 12 ≤ p.roofX d |
| have he1:= p.fluc he hx; linarith |
| · exact fun j _=>(p.shore v.m j).le |
| · intro j hj y he0 |
| exact p.decor he hj _ (h.shield j hj y he0) |
| · exact h.cooling |
| exact hx |
| |
| end HistoryC |
| end Fabric |
| end Line |
| end |
| end ExactDerandomization.SiteX |
| |
| end |
| |
| section |
| |
| namespace ExactDerandomization.SiteX.Line |
| open Counter Relay Rill Fret Chime Finset Grain Net Hie Est Analysis Stage Glass |
| open Helix Helix.Foil Helix.Age Helix.Moon Helix.Night Helix.Mold Helix.Orbit Scheme |
| open Dome Cone ConeX Buf At MintV CageQ |
| noncomputable section |
| open scoped Classical |
| variable {q w h:ℕ} {u:Line (q:=q) (w:=w) (h:=h)} |
|
|
| structure Producer where |
| tag : ℕ→ℕ→ℕ |
| locate : ℕ→ ℕ→ℕ |
| namespace Producer |
| variable (p:Producer) |
| abbrev awake (x i:ℕ):Prop:=p.tag x i≠0 |
| def coversF(x i:ℕ): Option (ℕ×ℕ):= if p.awake x i then some (p.tag x i,p.locate x i) else none |
| def scoreF (M:Mat) (x i:ℕ): ℝ:= if p.awake x i then M x (p.locate x i) else 0 |
| structure Light (p:Producer) (M:Mat)(S N:Domain):Prop where |
| insured:∀ x i,p.awake x i→x∈S ∧ p.locate x i∈N |
| fair:∀ x i j,p.awake x i→p.awake x j→p.locate x i=p.locate x j→i=j |
| defend:∀ x y,M x y≠0→∃ i,p.awake x i∧p.locate x i=y |
| structure Quote (u:Line (q:=q) (w:=w) (h:=h))(v:CageQ)(M:Mat)(which k:ℕ):Prop where |
| coil:CageQ.Front u v |
| trace:∀ x∈ u.D.P,v.Trace u x (p.tag x) (p.locate x) |
| voices:∀ x∈u.D.P,v.Offer u x which k (p.scoreF M x) |
|
|
| structure Certified (u:Line (q:=q) (w:=w) (h:=h))(v:CageQ)(M:Mat)(S N:Domain)(o k:ℕ):Prop where |
| light:p.Light M S N |
| suit:p.Quote u v M o k |
|
|
| namespace Quote |
| variable {p:Producer}{c M o k}(h0:Quote p u c M o k) |
| include h0 |
| lemma orbit {i x:ℕ}(hi:i<c.m)(hr:x∈u.D.P): |
| u.eye.Flora u.torch.p c.visN i x (p.coversF x i) := by |
| have ht:= (h0.trace x hr).road i (h0.coil.awake (h0.coil.size0 _ hi)) |
| unfold coversF; by_cases hz:p.awake x i |
| · rw [ite_eq_left hz]; rwa [ite_eq_right hz] at ht |
| rw [ite_eq_right hz]; rwa [ite_eq_left (show p.tag x i=0 from by simpa only [Producer.awake,ne_eq,not_not] using hz)] at ht |
| lemma lacks {x i}(he:x∈u.D.P)(hi:p.awake x i):i<c.m:=lt_of_not_ge fun e=>hi ((h0.trace _ he).maxm i e) |
| end Quote |
| namespace Certified |
| variable {p:Producer}{c M S N o k}(h0:p.Certified u c M S N o k) |
| include h0 |
| lemma supply (x y:ℕ)(he:x∈u.D.P): |
| ∑ i∈ range c.m,(if p.locate x i=y then p.scoreF M x i else 0)=M x y:=by |
| by_cases hp:M x y=0 |
| · rw [hp] |
| apply sum_eq_zero; intro i hi; unfold scoreF |
| unfold Producer.awake; grind |
| obtain ⟨i,h,hx⟩:= h0.light.defend x y hp |
| rw [sum_eq_single i] |
| · unfold scoreF; rw [ite_eq_left hx,ite_eq_left h,hx] |
| · intro j hj hz |
| by_cases hg:p.locate x j=y |
| · rw [ite_eq_left hg]; apply ite_eq_right; intro hh |
| exact hz (h0.light.fair x j i hh h (hg.trans hx.symm)) |
| rw [ite_eq_right hg] |
| intro hi; exact False.elim (hi (mem_range.2 (h0.suit.lacks he h))) |
| lemma pixels {x i}(he:x∈S)(hf:S⊆u.D.P):|p.scoreF M x i| ≤ massB k (u.D.D c.dataN):=by |
| by_cases ht:p.awake x i |
| · have hz:= h0.suit.lacks (hf he) ht |
| obtain ⟨v,hh,_⟩:= (h0.suit.voices x (hf he)).ready i (h0.suit.coil.awake (h0.suit.coil.size0 i hz)) |
| have he0:=hh.1 |
| change |_ / massB k (u.D.D c.dataN)| ≤ 1 at he0 |
| rwa [abs_div,abs_of_pos (mass0 ..),div_le_one (mass0 ..)] at he0 |
| unfold scoreF; rw [ite_eq_right ht]; simp only [abs_zero]; positivity |
| end Certified |
| end Producer |
| |
| namespace Fabric |
| variable (v:Fabric u) |
| abbrev α (m:MintV)(i:ℕ) : CageQ:= ⟨v.c 1 i,v.c 2 i,0, m.rangeN (gap v.m i)⟩ |
| abbrev Rslots(_:Fabric u) :=u.w0.p.K |
| abbrev Snum(i):= capacity 2 v.Rslots (Age.L v.m) i |
| abbrev β (i:ℕ): CageQ:=⟨v.c 3 i,v.c 4 i,0,v.Snum i⟩ |
| abbrev terminal (b:Bool): CageQ:=⟨v.c 9 0, v.c (if b then 11 else 10) 0,if b then 3 else 0,v.Rslots⟩ |
| abbrev leaveE : CageQ:= ⟨v.c 14 0,v.c 15 0,0,v.Rslots⟩ |
| abbrev final0:= v.t.need u.plotM |
| abbrev finalE := (forecast u.plotM v.m).outR v.t v.dye |
| abbrev grid := (v.t.builder u.plotM).sess v.dye |
| abbrev trio(b:Bool):Trio:= if b then suppT v.t.tag.theta false else v.t.trio u.plotM |
| abbrev grains:= v.t.rowBlock u.plotM v.roll v.m v.dye |
| abbrev aimE(b:Bool):Mat:=v.grid.pre v.grains (v.trio b) false |
| abbrev heated (b:Bool):ℕ:= if b then 4 else 1 |
| abbrev Tscale (p:MintV)(b:Bool):ℕ:= if b then 0 else p.coin |
|
|
| def slotWord (v:Fabric u)(i):=hole (v.c 12 0) i |
|
|
| structure Yolk (p:MintV)(i x:ℕ) where |
| hist:HistoryC v p x i |
| raw : Reed.Poolx |
| structure YFine (p:MintV)(i x:ℕ)(a:Yolk v p i x):Prop where |
| compared:HistoryC.Compared v a.hist |
| params:a.raw.p=(v.marathon x).pm i |
| posed:a.raw.raw=(v.marathon x).shifted i (HistoryC.actual v a.hist i) |
| ns:a.raw.m=(v.α p i).m |
| nice:a.raw.Nice |
|
|
| found:(v.α p i).Trace u x a.raw.tag a.raw.place |
| hue:∀ b,(v.α p i).Offer u x (if b then 1 else 2) p.inputH (fun j=> Reed.sideq (a.raw.chip j) b) |
| baseX:u.D.Voice (v.c 1 i) x (hole 5 0) (u.D.high (v.c 1 i)) (p.inputH*u.D.D (v.c 1 i)) a.raw.b |
| cap : ∀ y∈(v.marathon x).S,ht ((v.marathon x).inc i y) ≤ massB p.tokenH (gap v.m i) |
| night:x∉v.S0→∀ i,a.raw.tag i=0 |
|
|
| structure Hinge (p:MintV) (i x:ℕ) where |
| hist:HistoryC v p x (i+1) |
| depot:Stem.Depot |
| structure HFine (p:MintV)(i x:ℕ)(a:Hinge v p i x):Prop where |
| y0 : HistoryC.Compared v a.hist |
| ton : a.depot.y=HistoryC.actual v a.hist (i+1) |
| dst : a.depot.S=v.S1 |
| card0:a.depot.n=v.Snum i |
| solid:a.depot.Trust |
| found:(v.β i).Trace u x a.depot.tag a.depot.pos |
| hue:(∀ b,(v.β i).Offer u x (if b then 1 else 2) p.sealR (fun j=>Reed.sideq (a.depot.qpoint j) b)) |
| at0:u.D.Voice (v.c 3 i) x (hole 5 0) (u.D.high (v.c 3 i)) (p.sealR*u.D.D (v.c 3 i)) a.depot.y.base |
| kill:x∉v.S0→∀ i,¬a.depot.live i |
|
|
| structure Tgood(p:MintV)(f:Bool→Producer):Prop where |
| secure:∀ b,(f b).Certified u (v.terminal b) (v.aimE b) v.S0 v.S1 (heated b) (Tscale p b) |
| seat :∀ x i,(f false).awake x i→ v.aimE true x ((f false).locate x i)=1 |
|
|
| /-- mating on the pre-cap main ports. Captures baseline order by specifying only its needed invariants. -/ |
| structure Profession (f:Producer)(tb:ℕ→ℕ→ℕ) :Prop where |
| t1:u.D.active (v.c 12 0) |
| bound : ∀ x i,tb x i ≠0 → f.awake x i ∧tb x i ≤ clim u.w0.p |
| quota :∀ x i,f.awake x i → |
| (tb x i≠0 ↔ (u.D.P.filter (fun a=>∃ j, f.awake a j ∧ f.locate a j=f.locate x i)).card ≤ clim u.w0.p) |
| guide :∀ x∈ u.D.P,∀ i<v.Rslots,∀ t,0<t→ t ≤ clim u.w0.p→ |
| u.D.dual (v.slotWord i) t ∧ |
| u.D.Streams (v.slotWord i) (u.D.curve (v.slotWord i)) ∧ |
| u.D.curve (v.slotWord i) t true x= if tb x i=t then some (f.locate x i) else none |
|
|
| /-- Final matrix port operations, including paired information for echoes. -/ |
| structure Efine (p:MintV)(f:Producer):Prop where |
| sector:f.Certified u v.leaveE v.finalE v.S0 v.S1 1 p.coin |
| ticket:u.D.active (v.c 12 0) ∨ v.govern=false |
| tin : v.govern=true→∀ x i,f.awake x i→ f.tag x i ≤ clim u.w0.p |
| source : v.govern=true→∀ i<v.Rslots,∀ t,0<t→ t ≤ clim u.w0.p→ |
| u.D.dual (v.slotWord i) t ∧ |
| u.D.Streams (v.slotWord i) (u.D.curve (v.slotWord i)) ∧ |
| ∀ x∈ u.D.P,u.D.curve (v.slotWord i) t true x= |
| if f.tag x i=t then some (f.locate x i) else none |
|
|
| end Fabric |
| end |
| end ExactDerandomization.SiteX.Line |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.SiteX |
| open Counter Relay Rill Fret Chime Finset Grain Net Hie Est Analysis Stage Glass Plaza _root_.OAI.ExactDerandomization.Sub |
| open Helix Helix.Foil Helix.Age Helix.Moon Helix.Night Helix.Mold Helix.Orbit Scheme |
| open Dome Cone ConeX Buf At MintV Line Line.Fabric |
| noncomputable section |
| namespace Label |
| abbrev gob (v:ℕ)(_:Word)(u:ℕ):ℕ:= pointer (unitK u) v |
| lemma gobK(v):Kn (gob v):= by |
| have hp:=(Kn.unpack (α:=Crt)).comp unitK0 |
| exact Kn.wash.comp ((Kn.fix _).tuple hp.right) |
| abbrev PURE :ℕ:=30 |
| variable {q w h:ℕ}(z: Rock q w h) (v:Tags) |
|
|
| def put (x:Word)(t:ℕ):ℕ:= min (2^T z v x) (2^date t) |
| lemma putK:Kn (put z v):= by |
| have hp:= (stationK z v (α:=ℕ)) |
| exact Kn.cap hp (Kn.fix _) tokenK.right |
|
|
| def followP (l y :ℕ) (x:Word)(a:Mint.Bean):ℕ:= |
| post (gob l x a.1) y a.2.1 (date a.1-a.2.2) |
| lemma followK(l y):Kn (followP l y):= by |
| have h:= Kn.first (β:=Rill.History) (α:=ℕ) |
| have hp:=Kn.wash.comp (((gobK l).comp h).tuple (Kn.wash.comp ((Kn.fix y).tuple Kn.next.left))) |
| exact Kn.wash.comp (hp.tuple (((tokenK.right).comp h).sub Kn.next.right)) |
| def roadX (cap0:Bool) (i l y:ℕ):Road:= |
| ⟨⟨_,gobK i⟩,⟨_,Kn.fix z.w.p.K⟩, if cap0 then ⟨_,Kn.fix 0⟩ else ⟨_,tokenK.right.succ⟩, |
| ⟨_,followK l y⟩,if cap0 then ⟨_,Kn.fix 0⟩ else ⟨_,padK ⟨_,putK z v⟩⟩⟩ |
| end Label |
|
|
| namespace Line |
| namespace Fabric |
| variable {q w h:ℕ} {u:Line (q:=q) (w:=w) (h:=h)} |
| open Label |
| variable (v:Fabric u) |
|
|
| lemma pointerot (a b:ℕ):pointer (v.c a 0) b=v.c b 0:=by |
| unfold c rowL clr pointer; rw [Wire.eq] |
| @[simp] lemma awayT (a i o t b): gob b u.x (post (v.c a 0) o i t)=v.c b 0:=by |
| rw [gob,bellU,v.pointerot] |
|
|
| def diva (p:Fabric u) (f:Producer)(κ unitα l v α :ℕ) (cap0:Bool) : Ember:= |
| ⟨u.eye,u.torch.p,roadX u.r u.v cap0 v l α,p.c v 0,p.Rslots,κ,u.v.A,p.c unitα 0, |
| hole Label.PURE 0,f.coversF⟩ |
| lemma weightEnd (a)(ha:¬ Brole a): u.D.W (v.c a 0)=128*(v.m+1)-(64-a)*1:=by |
| change Age.W _=_ |
| unfold c rowL clr; rw [WI]; unfold act weight slackT |
| rw [ite_eq_right (show ¬Brole a from ha)] |
| lemma ageEnd (a)(ha:¬ Brole a):u.D.D (v.c a 0)=1:=by |
| unfold c rowL; change Age.D _=_ |
| rw [Line.rolff,slackT,ite_eq_right ha] |
| lemma parentL {a b}(hi:¬ Brole a)(he:a<b)(hk:b ≤ 64): |
| u.D.W (v.c a 0)+1 ≤ u.D.W (v.c b 0):=by |
| have hB:¬Brole b:=by unfold Brole at *; omega |
| rw [weightEnd v a hi,v.weightEnd _ hB] |
| omega |
| structure Mantle (κ:ℕ):Prop where |
| chart:u.Chart |
| k :100 ≤ κ |
| space0:lb capD ≤ κ |
| grade: 100*u.eye.e ≤ κ |
| grown:1000*κ^2 ≤ u.v.A |
| heat:u.v.A ≤ u.v.slope |
| holdp:∀ i<v.Rslots,lb i ≤ κ |
|
|
| namespace Mantle |
| variable {v:Fabric u}{κ:ℕ}(h0:Mantle v κ) |
| include h0 |
| lemma ties {unitα a l α:ℕ} (ha:¬Brole a) (he:a<unitα)(hl:unitα ≤ 64)(b:Bool){f M o x z} |
| (hg:Producer.Quote f u |
| (CageQ.mk (v.c l 0) (v.c a 0) z v.Rslots) M o x) |
| (hp:u.D.Suite (v.c unitα 0))(hh:u.D.Heard (v.c unitα 0)): |
| (v.diva f κ unitα l a α b).Trust:=by |
| exact ⟨hp,hh,v.ageEnd _ (by unfold Brole at *; omega),v.ageEnd _ ha, |
| Nat.le_trans (Nat.le_add_right ..) (v.parentL ha he hl),h0.k,h0.grade,h0.grown,h0.heat,h0.holdp, |
| fun x hx y hy=>hg.orbit hy hx⟩ |
| lemma bridge {unitα a l α t:ℕ}(b:Bool)(f:Producer)(h:u.D.active (v.c unitα 0)) |
| (he:t ≤ u.D.high (v.c unitα 0)) : |
| (v.diva f κ unitα l a α b).Bridge t := by |
| let p:=v.diva f κ unitα l a α b |
|
|
| refine ⟨he,?_,le_rfl,rfl,?_,?_⟩ |
| · exact v.awayT .. |
| · cases b |
| · change date (post (v.c unitα 0) PURE 0 t) + 1 ≤ t + κ |
| rw [bellT]; have hz:=h0.k; omega |
| change 0 ≤ _; omega |
| change 2^(charge _ (Age.W (v.c unitα 0)) t) ≤ 2^charge u.v.A (planets u.r u.x) (T u.r u.v u.x) |
| apply Nat.pow_le_pow_right (by omega) |
| have hs:=licensedW u.r ((Line.Chart.auth (u := u) (v.c unitα 0)).1 h) |
| have hL := Night.cap_time u.r u.v u.x u.prog (v.c unitα 0) t he |
| change charge u.v.A (Age.W (v.c unitα 0)) t ≤ _ |
| unfold charge; gcongr |
| end Mantle |
| |
| end Fabric |
| end Line |
| end |
| end ExactDerandomization.SiteX |
| |
| end |
| |
| section |
| |
| namespace ExactDerandomization.SiteX |
| open Counter Relay Rill Fret Chime Finset Grain Net Hie Est Analysis Stage Glass Plaza _root_.OAI.ExactDerandomization.Sub |
| open Helix Helix.Foil Helix.Age Helix.Moon Helix.Night Helix.Mold Helix.Orbit Scheme |
| open Dome Cone ConeX Buf At MintV Line Line.Fabric Producer |
| open Fret.Seats Reed |
| noncomputable section |
| |
| namespace Studio |
| /-- allocate main's body by operation tags. -/ |
| def stacc (q:ℕ)(u:ℕ):ℕ:=enc ((q,u,0):Reed.Stool) |
| def collapse (_:Word)(q:ℕ):ℕ:= postcard (stacc (unitK q) (posn q)) (date q) |
| lemma lidK:Kn (fun (_:Word) q=>posn q):=tokenK.right.comp (tokenK.right.comp tokenK.left) |
| lemma oK:Kn (fun (_:Word) q=>opt q):=tokenK.left.comp (tokenK.right.comp tokenK.left) |
| lemma collapseK:Kn collapse:= |
| Kn.wash.comp ((Kn.wash.comp (unitK0.tuple (lidK.tuple (Kn.fix 0)))).tuple tokenK.right) |
| def erode (p:Cog):Cog:=Cog.ren ⟨_,collapseK⟩ p |
| def enter(p:ℕ):Relay.Flag:= ⟨_,(oK.comp Kn.first).eq (Kn.fix p)⟩ |
| def arrange (f:ℕ → Cog):ℕ → Cog |
| | 0=>erode (f 0) |
| | i+1=> .bif (enter (i+1)) (erode (f (i+1))) (arrange f i) |
|
|
| lemma arr {i x y q c d l b M n t} (h:l.Mane c b d (postcard (stacc q i) t) (M n) x y) {j:ℕ}(ht:n ≤ j): |
| Lot.Mane l c b d (post q n i t) (arrange M j) x y:=by |
| have hf: Lot.Mane l c b d (post q n i t) (erode (M n)) x y:=by |
| apply Cog.renameR _ h; simp [collapse,post] |
| induction j with |
| | zero=>have he:n=0:=by omega |
| subst n; exact hf |
| | succ j ih=> |
| by_cases he:n=j+1 |
| · subst n |
| exact .yes (show decide (opt _=j+1)=true by rw [optionX]; simp) hf |
| exact .no (show decide (opt _=j+1)=false by rw [optionX]; simp [he]) (ih (by omega)) |
| |
| variable {q w h:ℕ}{u:Line (q:=q) (w:=w) (h:=h)} |
| abbrev dockA (u:Line (q:=q) (w:=w) (h:=h))(r x:ℕ):Seats:= u.D.chord r x r |
| abbrev stk(u:Line (q:=q) (w:=w) (h:=h))(v x i:ℕ):Seats:=Reed.film (dockA u v x) i 0 |
| @[simp] lemma stalk(v x i:ℕ):stacc v i=(stk u v x i).info:=rfl |
| /-- direct untransformed data-station program assigned at one valid card. -/ |
| def Parcel (u:Line (q:=q) (w:=w) (h:=h))(a:ℕ)(p:Cog):Prop:= |
| ∀ v b c x y,unitK v=a→ u.D.l.Mane c b (u.D.D a) v p x y→ |
| u.D.l.Mane c b (u.D.D a) v u.D.l.P x y |
| lemma stationed {p:Cog}{a:ℕ} (_:u.Chart)(he:u.D.active a)(hr:a≠0) |
| (hh:∃ _:(uphold a).1≠0, ∀ i,(i=2∨i=4∨i=10∨i=11∨i=15)→(uphold a).1≠i) |
| (hx:u.s.scripted (uphold a).1=p):Parcel u a p:=by |
| intro v b c0 x y ht hq |
| apply (Line.Chart.assigned (u := u)) he ht |
| unfold who; rw [ht,ite_eq_right hr] |
| obtain ⟨hI,hY⟩:=hh |
| unfold codeRank; rw [ite_eq_right hI,ite_eq_right (fun e=>hY _ e rfl),hx] |
| exact hq |
| |
| lemma echoTicket {a x i j c o m:ℕ}{f:ℕ → Cog}(h: u.D.Suite a) |
| (hr:o ≤ m)(hs:o ≤ 32)(ht:u.smallQ a i)(hh:2 ≤ c)(he:c ≤ u.v.slope)(hv:rite (stk u a x i) c (f o) j) |
| (hz:Parcel u a (arrange f m)): |
| u.D.swears (post a o i 0) x j:= by |
| intro b hb |
| apply h.hired _ 0 (u.Launch h.stage i o 0 ht hs (Nat.zero_le _)) (by omega:1 ≤ c) |
| (show c ≤ u.D.slope from he) |
| apply hz _ _ c _ _ (bellU ..) |
| exact arr (hv (Dome.glove b x) ⟨_,hb,rfl⟩) hr |
|
|
| lemma scoreTicket {a x i j c o m H:ℕ}{f:ℕ → Cog}(h: u.D.Suite a)(hr:o ≤ m)(hs:o ≤ 32)(ht:u.smallQ a i) |
| (hh:2 ≤ c)(he:c ≤ u.v.slope)(hx:H ≤ u.D.high a) |
| {V:ℝ}(hp: band (stk u a x i) c H j (f o) V)(hz:Parcel u a (arrange f m)): |
| u.D.Voice a x (hole o i) H (j*u.D.D a) V:=by |
| obtain ⟨w,hp⟩:=hp |
| refine ⟨w,(hp _ (hm (stk u a x i))).1,?_⟩ |
| intro t hk b he' |
| apply h.hired _ t (u.Launch h.stage i o t ht hs (hk.trans hx)) (by omega:1 ≤ c) |
| (show c ≤ u.D.slope from he) |
| apply hz _ _ c _ _ (bellU ..) |
| exact arr ((hp _ ⟨b,he',rfl⟩).2.digits t hk) hr |
|
|
| lemma positioned {a x}(h:u.D.Suite a)(he:x∈u.D.P)(i j): |
| stable (Reed.film (dockA u a x) i j) (Reed.campk (Mold.knob u.r u.v)):=by |
| apply spread |
| apply Mold.knows u.r u.v u.x u.prog a x (by classical exact of_decide_eq_true h.stage) he |
| (show 2 ≤ u.v.slope from h.shape.price) |
|
|
| lemma vital {a x}(H:ℕ)(h:H ≤ u.D.H): |
| Fret.Live (dockA u a x).head (Mold.knob u.r u.v) H:= |
| Nat.pow_le_pow_right Nat.zero_lt_two h |
|
|
| lemma stayedC {a}(he:u.D.Suite a){t c}(hu:t ≤ u.D.high a)(hh:c ≤ u.v.slope): t+c*u.D.D a ≤ u.D.H:=by |
| have he0:= (u.D.till a t).2 ⟨hu,he.paid⟩ |
| unfold Dome.won Dome.loadC at he0 |
| change c ≤ u.D.slope at hh |
| exact le_trans (Nat.add_le_add_left (Nat.mul_le_mul hh he.well.2) _) he0 |
| lemma soonerC {a b H c}(he:u.D.Suite b)(hp:u.D.W a+u.D.D b ≤ u.D.W b) |
| (hh:c ≤ u.v.slope)(hz:H ≤ u.D.high b): H+c*u.D.D b ≤ u.D.high a:=by |
| apply le_trans _ (he.descend hp).2 |
| exact Nat.add_le_add hz (Nat.mul_le_mul_right _ hh) |
| end Studio |
|
|
| end |
| end ExactDerandomization.SiteX |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.SiteX.Label |
| open Counter Relay Rill Fret Chime Finset Grain Net Hie Est Analysis Stage Glass Plaza _root_.OAI.ExactDerandomization.Sub |
| open Helix Helix.Foil Helix.Age Helix.Moon Helix.Night Helix.Mold Helix.Orbit Scheme |
| open Dome Cone ConeX Buf At MintV Line Line.Fabric |
| noncomputable section |
| open scoped Classical |
| /- cap invocation program uses a common graph virtual q. -/ |
| def substitute (_:Word)(q:ℕ):ℕ:=post (unitK q) Label.PURE 0 (date q) |
| lemma substituteK:Kn substitute:=Kn.wash.comp ((Kn.wash.comp (unitK0.tuple (Kn.fix (hole Label.PURE 0)))).tuple tokenK.right) |
| def renbody(P:Cog):Cog:=Cog.ren ⟨_,substituteK⟩ P |
| lemma reprise {u q l c b p k i s}(hp:Lot.Mane l c b k u p i s)(he:substitute l.x q=u): |
| Lot.Mane l c b k q (renbody p) i s:= Cog.renameR _ hp he |
|
|
| abbrev Ticket := Bool × ℕ × ℕ |
| def match0(i j:ℕ)(_:Word)(q:Plot):Bool:= |
| let b:Ticket:=dec (Scheme.which q.1) |
| decide (b.2=(i,j)) |
|
|
| lemma match0K(i j:ℕ):Kn (match0 i j):=by |
| have hl:= tokenK.comp tokenK.left|>.right |
| let g:= ((Kn.unpack (α:=Ticket)).comp (hl.comp (Kn.first (β:=Site)))).right |
| convert Print.both (g.left.eq (Kn.fix i)) (g.right.eq (Kn.fix j)) using 1 |
| ext x q |
| rw [Bool.eq_iff_iff] |
| simp only [match0, decide_eq_true_eq, Bool.and_eq_true, Prod.ext_iff] |
| rfl |
| def outwardP(_:Word)(q:Plot):Bool:=(dec (Scheme.which q.1):Ticket).1 |
| lemma outwardK : Kn outwardP := by |
| have hl:= tokenK.comp tokenK.left|>.right |
| exact ((Kn.unpack (α:=Ticket)).comp (hl.comp (Kn.first (β:=Site)))).left |
|
|
| abbrev placeholder := Cog.edit ⟨_,Kn.next⟩ |
| variable {q w h:ℕ} |
| def motionR (z:Rock q w h)(v:Tags)(p:Pose)(i j:ℕ)(otherwise:Cog): Cog:= |
| let f(b:Bool):= renbody (Ember.cutWay (coneX z p) (roadX z v true 10 9 0) (schedule z v) v.A |
| (clim z.w.p) i j b) |
| Cog.bif ⟨_,match0K i j⟩ (.bif ⟨_,outwardK⟩ (f true) (f false)) otherwise |
| def fold0 {r:Rock q w h}(v:Tags)(p:Pose) (l:List (ℕ×ℕ)):Cog:= match l with |
| | []=>placeholder |
| | f0::l=> motionR r v p f0.1 f0.2 (fold0 (r:=r) v p l) |
| abbrev neighbors (c:Const) := (range c.K) ×ˢ range (clim c+1) |
| abbrev fullB (r:Rock q w h)(v:Tags) (p:Pose):Cog:= fold0 (r:=r) v p (neighbors r.w.p).toList |
| lemma came (t:Ticket)(j:ℕ): |
| (dec (Scheme.which (bell j (enc t) 0)):Ticket)=t:=by rw [bellV,dec_round] |
| lemma pickout(r:Rock q w h) (v:Tags)(p:Pose){n i j:ℕ}(u:List (ℕ×ℕ)) |
| (he:(i,j)∈ u)(b:Bool){l c B s a k} |
| (hp:Lot.Mane l c B k (bell n (idx b i j) 0) |
| (renbody (Ember.cutWay (coneX r p) (roadX r v true 10 9 0) (schedule r v) v.A |
| (clim r.w.p) i j b)) s a): |
| Lot.Mane l c B k (bell n (idx b i j) 0) (fold0 (r:=r) v p u) s a:=by |
| induction u with |
| | nil=> simp at he |
| | cons x u ih=> |
| obtain ⟨a1,b1⟩:=x |
| by_cases hz: i=a1∧j=b1 |
| · obtain ⟨rfl,rfl⟩:=hz |
| apply Lot.Mane.yes |
| · unfold match0; simp only [idx,came,decide_true] |
| cases b |
| · exact Lot.Mane.no (by unfold outwardP; simp only [idx,came]) hp |
| exact Lot.Mane.yes (by unfold outwardP; simp only [idx,came]) hp |
| apply Lot.Mane.no _ (ih (by simpa [hz] using he)) |
| unfold match0; simp [idx,hz] |
| end |
| end ExactDerandomization.SiteX.Label |
| |
| end |
| |
| section |
| |
| namespace ExactDerandomization.SiteX.Line.Fabric |
| open Counter Relay Rill Fret Chime Finset Grain Net Hie Est Analysis Stage Glass Plaza _root_.OAI.ExactDerandomization.Sub |
| open Helix Helix.Foil Helix.Age Helix.Moon Helix.Night Helix.Mold Helix.Orbit Scheme |
| open Dome Cone ConeX Buf At MintV Line Line.Fabric Producer Label |
| noncomputable section |
| open scoped Classical |
| |
| variable {q w h:ℕ}{u:Line (q:=q) (w:=w) (h:=h)} |
| variable (v:Fabric u)(p:Producer)(κ:ℕ) |
| abbrev alongE :=v.diva p κ 12 9 10 0 true |
| abbrev core12 := v.c 12 0 |
| variable {v p κ} |
| lemma cap_dual {i t}(h:u.D.Suite v.core12): |
| u.D.dual (v.slotWord i) t↔ i<v.Rslots ∧1 ≤ t∧ t ≤ clim u.w0.p := by |
| let x:=v.core12 |
| change decide (paired u.r u.v u.x (hole x i,t))=true ↔_ |
| have h0:x≠0:=Age.cpos _ |
| rw [decide_eq_true_eq]; unfold paired |
| have hp: (dec x:Crt).1=12:=by simp [x,core12,c,rowL,clr,kit] |
| have hz: licensed u.r u.x x:=of_decide_eq_true h.stage |
| simp [cell,Scheme.inside,hole,x,hp,h0,hz] |
|
|
| lemma adding (v:Fabric u)(i z)(b:Bool): u.D.pulseQ (v.slotWord i) z b=bell v.core12 (idx b i z) 0:=by |
| change (schedule u.r u.v).before b u.D.x (slotWord v i,z)=_ |
| simp [Scheme.before,schedule,cell,Scheme.inside,hole,location,slotWord,core12] |
|
|
| structure Bloom12 (v:Fabric u)(p:Producer)(κ:ℕ)(l:ℕ→List Swirl.Gem):Prop where |
| quilt:(alongE v p κ).Quilt |
| mouth:(alongE v p κ).Mouth l quilt |
| namespace Bloom12 |
| variable {l:ℕ→List Swirl.Gem}(h0:Bloom12 v p κ l) |
| include h0 |
|
|
| lemma funded (hS:u.v.A*(2*u.v.A+40) ≤ u.v.slope) |
| (_:v.Mantle κ) |
| (hf:∀ i z b,i<v.Rslots→ 1 ≤ z→z ≤ clim u.w0.p→∀ a y, |
| Lot.Mane u.D.l u.v.slope ⟨u.D.W v.core12,0⟩ 1 (bell v.core12 (idx b i z) 0) (fullB u.r u.v u.s.pave) a y → |
| Lot.Mane u.D.l u.v.slope ⟨u.D.W v.core12,0⟩ 1 (bell v.core12 (idx b i z) 0) u.D.l.P a y) |
| (i:ℕ): u.D.Streams (v.slotWord i) ((v.alongE p κ).valueOf l (clim u.w0.p) i) := by |
| let e:=v.alongE p κ; have hh:u.D.Suite v.core12:=h0.quilt.h.supply |
| let k:=clim u.w0.p |
| refine ⟨fun z hz x hx b r hr=>?_,fun z hz x hx b r hg=>?_,fun x hx z hz y hy r m he hp=>?_⟩ |
| · have he:u.D.pulseQ (v.slotWord i) z b=bell v.core12 (idx b i z) 0:=v.adding .. |
| have hp:= (cap_dual hh).1 hz |
| have hC := h0.mouth.clearsWay k i hp.1 z b hx hr |
| let c:= e.valueOf l k i z b x |
| have hi:Lot.Mane u.D.l (Ember.stepC e.A) ⟨u.D.W v.core12,0⟩ 1 (bell v.core12 (idx b i z) 0) |
| (renbody (Ember.cutWay e.p e.R e.D.s e.A k i z b)) (0,glove r x) (Dome.AtM c r x):= |
| reprise hC (by simp [substitute]; rfl) |
| have hj:i<v.Rslots:=hp.1; have hz1:z ≤ clim u.w0.p:= hp.2.2 |
| have hk: Lot.Mane u.D.l (Ember.stepC e.A) ⟨u.D.W v.core12,0⟩ 1 (bell v.core12 (idx b i z) 0) |
| (fullB u.r u.v u.s.pave) (0,glove r x) (Dome.AtM c r x):= by |
| refine pickout u.r u.v u.s.pave _ ?_ b hi |
| simpa only [Finset.mem_toList,neighbors,mem_product,mem_range] using (show i < v.Rslots ∧ z<clim u.w0.p+1 from ⟨hp.1,by omega⟩) |
| have hn : 1 ≤ Ember.stepC e.A:=by |
| have hs:=h0.quilt.h.skeleton; have hz:=h0.quilt.h.budget |
| change _ ≤ e.A at hz; unfold Ember.stepC; change _ ≤ e.k at hs; nlinarith |
| have hG := hf i z b hp.1 hp.2.1 hp.2.2 _ _ (hk.mono hS hn) |
| have ht:= Night.pairbill u.r u.v u.x u.prog (v.slotWord i) z hz b |
| have hg:u.D.pulseQ (v.slotWord i) z b ≤ u.D.F.limit:=ht |
| rw [he] at hg ⊢ |
| have hp0:u.D.D v.core12=1:=v.ageEnd _ (by decide) |
| rw [← hp0] at hG |
| exact hh.hired _ 0 hg (by have :=hh.shape.price; change 1 ≤ u.v.slope; change 2 ≤ u.v.slope at this; omega) |
| (by change u.v.slope ≤ u.v.slope; exact le_rfl) hG |
| · have he:=h0.mouth.disp.1 hg |
| exact ⟨(h0.mouth.pointIn he).1,h0.mouth.disp.2 ((Ember.Mouth.exchange0 b).1 he)⟩ |
| exact (h0.mouth.unique0 he hp).symm |
|
|
| abbrev flood (_:Fabric u)(p:Producer)(y:ℕ) : Finset ℕ:= |
| u.D.P.filter (fun a=>∃ j, p.awake a j ∧ p.locate a j=y) |
| lemma swell {pay o M}(hs:Certified p u (v.terminal false) M v.S0 v.S1 o pay){y}(he:y∈u.D.P): |
| (l y).length=(flood v p y).card:=by |
| let b:=v.alongE p κ; let F:=b.pie l clearG |
| have ht : Deck.Licence F (h0.quilt.p.lit h0.quilt.h clearG u.D.cleared):=h0.mouth.fitL _ u.D.cleared |
| let f(g:Swirl.Gem):= g.1.2 |
| have hg:(l y).toFinset.image f=flood v p y:=by |
| ext a; constructor |
| · intro hi; obtain ⟨j,hj,rfl⟩:=mem_image.1 hi |
| obtain ⟨x,hx,i,hl,rfl,hk⟩:= (ht.trace0 he).1 (show j∈F.trace y from List.mem_toFinset.mp hj) |
| change (p.coversF x i).map _=some y at hk; unfold coversF at hk |
| split at hk |
| · next he=> simp only [Option.map_some,Option.some.injEq] at hk; exact mem_filter.2 ⟨hx,i,he,hk⟩ |
| contradiction |
| intro hi; obtain ⟨ha,i,hp,hq⟩:=mem_filter.1 hi |
| have hw:i<v.Rslots:=hs.suit.lacks ha hp |
| refine mem_image.2 ⟨pledge a i,List.mem_toFinset.2 ?_,rfl⟩ |
| change pledge a i∈F.trace y |
| exact (ht.trace0 he).2 ⟨a,ha,i,hw,rfl,show (p.coversF a i).map _ = some y by |
| unfold coversF; rw [ite_eq_left hp]; simp [hq]⟩ |
| have hi : Set.InjOn f (l y).toFinset:= by |
| intro c hc g hh hx |
| obtain ⟨x,hA,i,hi,hc0,h1⟩:= (ht.trace0 he).1 (show c∈F.trace y from List.mem_toFinset.mp hc) |
| obtain ⟨x',hB,j,hj,hh0,h2⟩:= (ht.trace0 he).1 (show g∈F.trace y from List.mem_toFinset.mp hh) |
| have hf : x=x':=by rw [hc0,hh0] at hx; exact hx |
| have hs1 {x i}(h:F.f x i=some y):p.awake x i ∧ p.locate x i=y:=by |
| change (p.coversF x i).map _=some y at h |
| unfold coversF at h; split at h |
| · next hh=>simp only [Option.map_some,Option.some.injEq] at h; exact ⟨hh,h⟩ |
| contradiction |
| subst x' |
| obtain ⟨ha,hx1⟩:=hs1 h1; obtain ⟨hb,hx2⟩:=hs1 h2 |
| rw [hc0,hh0,hs.light.fair x i j ha hb (hx1.trans hx2.symm)] |
| rw [← hg, card_image_iff.2 hi,List.toFinset_card_of_nodup (show (l y).Nodup from (ht.wheels _ he).unique)] |
| end Bloom12 |
|
|
| end |
| end ExactDerandomization.SiteX.Line.Fabric |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.SiteX.Line.Fabric |
| open Counter Relay Rill Fret Chime Finset Grain Net Hie Est Analysis Stage Glass Plaza _root_.OAI.ExactDerandomization.Sub |
| open Helix Helix.Foil Helix.Age Helix.Moon Helix.Night Helix.Mold Helix.Orbit Scheme |
| open Dome Cone ConeX Buf At MintV Line Line.Fabric Producer Label |
| noncomputable section |
| open scoped Classical |
|
|
| variable {q w h:ℕ}{u:Line (q:=q) (w:=w) (h:=h)} |
| variable (v:Fabric u)(f:Producer) |
| /- B rank roles station. -/ |
| structure Stand where |
| a:ℕ |
| i:ℕ |
| l:ℕ |
| o:ℕ |
| t:ℕ |
| k:ℕ |
| namespace Stand |
| abbrev cage (s: Stand)(v:Fabric u): CageQ:=⟨v.c s.l 0,v.c s.i 0,s.t,v.Rslots⟩ |
| abbrev beacon (s: Stand)(v:Fabric u)(f:Producer)(p:ℕ): Ember:=v.diva f p s.a s.l s.i s.o false |
| abbrev H (s: Stand)(v:Fabric u):ℕ:=u.D.high (v.c s.a 0) |
| variable (s:Stand) |
|
|
| abbrev bank(s:Stand)(v:Fabric u)(f:Producer)(M:Mat)(k p:ℕ)(w:ℕ→ℕ→ Tape):Ember.Forest (s.beacon v f p):= |
| ⟨⟨_,putK u.r u.v⟩,s.H v,s.k,fun x i=> f.scoreF M x i/(2:ℝ)^k,w⟩ |
|
|
| structure Law (p k:ℕ)(M:Mat):Prop where |
| reg:v.Mantle p |
| plot: v.Good |
| auth : u.D.Suite (v.c s.a 0) |
| heard : u.D.Heard (v.c s.a 0) |
| ready:s.i<s.a∧s.l<s.a ∧ 5<s.i ∧ 5<s.l ∧ s.a ≤ 64 |
| mode : Orbit.colorQ s.o s.l |
| M0 : f.Certified u (s.cage v) M v.S0 v.S1 s.o k |
| pos:∀ x i,0 ≤ f.scoreF M x i |
|
|
| namespace Law |
| variable {s k v f p M}(hp:s.Law v f p k M) |
| include hp |
|
|
| lemma promoted :∃ w,Ember.Forest.Archive (s.bank v f M k p w) := by |
| obtain ⟨hi,hl,hI,hL,hB⟩:=hp.ready |
| have hL0:¬Brole s.l:=by unfold Brole; omega |
| have hI0:¬Brole s.i:=by unfold Brole; omega |
| have hA0:¬Brole s.a:=by unfold Brole; omega |
| let B:=s.cage v |
| have hc:=hp.M0.suit.coil |
| have heD:u.D.D (v.c s.l 0)=1:=v.ageEnd _ hL0 |
| have heA:u.D.D (v.c s.a 0)=1:=v.ageEnd _ hA0 |
| have heW:u.D.W (v.c s.l 0)+1 ≤ u.D.W (v.c s.a 0):=v.parentL hL0 hl hB |
| have hq:u.D.high (v.c s.a 0) ≤ u.D.high (v.c s.l 0):=by |
| unfold high; have he:=Nat.mul_le_mul_left u.D.slope (show u.D.W (v.c s.l 0) ≤ _ from |
| (Nat.le_add_right ..).trans heW); omega |
| let e:=s.beacon v f p |
| have ht:e.Trust:= hp.reg.ties hI0 hi hB _ hp.M0.suit hp.auth hp.heard |
| have hx(a i:ℕ):∃ w,a∈ u.D.P→ i<v.Rslots→u.D.StageW (v.c s.l 0) a (hole s.o i) (u.D.high (v.c s.l 0)) k (f.scoreF M a i) w:=by |
| by_cases hX:a∈ u.D.P∧ i<v.Rslots |
| · obtain ⟨w,hW⟩:= (hp.M0.suit.voices a hX.1).ready i (hc.awake (hc.size0 _ hX.2)) |
| have ht : k*u.D.D (s.cage v).dataN=k:=by change k*u.D.D (v.c s.l 0)=k; rw [heD,mul_one] |
| rw [ht] at hW; exact ⟨w,fun _ _=>hW⟩ |
| exact ⟨fun _=>0,fun he ht=> (hX ⟨he,ht⟩).elim⟩ |
| choose tape hw using hx |
| let g:= s.bank v f M k p tape; have he(t:ℕ)(h:t ≤ g.H) :g.topk.f e.D.x (e.Q t)=2^t :=by |
| change Label.put u.r u.v u.x (e.Q t)=_ |
| unfold Label.put; rw [bellT] |
| exact min_eq_right (Nat.pow_le_pow_right Nat.zero_lt_two |
| (cap_time u.r u.v u.x u.prog _ t h)) |
| refine ⟨tape,ht,fun t hs=>hp.reg.bridge _ f hp.auth.stage hs,?_,he,fun t h0=>?_ ,rfl, hp.reg.space0, ?_⟩ |
| · intro i hi' a ha |
| have hW:= hw a i ha hi' |
| refine ⟨div_nonneg (hp.pos a i) (by positivity),?_,fun j hj=>?_⟩ |
| · exact hW.scored.1 |
| exact hW.scored.2 j (hj.trans hq) |
| · change date (e.Q t)+1=_ |
| rw [bellT] |
| dsimp only |
| intro t h0 i hi0 j hj |
| let y:=g.q t i j |
| have hY:y=post (v.c s.l 0) s.o i (t-j):=by |
| change followP s.l s.o u.x (e.Q t,i,j)=_ |
| unfold followP; rw [bellT]; have he:gob s.l u.x (e.Q t)=v.c s.l 0:=v.awayT _ _ _ _ _ |
| rw [he] |
| change e.D.audible y∧date y ≤ _ ∧ e.D.W (unitK y)<_ ∧ ∀ x∈e.D.P,e.D.echo y x= enc _ |
| rw [hY,bellU,bellT] |
| refine ⟨u.spokenC hc.pos (Age.cpos _) _ _ _ (hc.awake (hc.size0 i hi0)) (Or.inr (by rw [show (uphold (s.cage v).dataN).1=s.l from by simp [uphold, c,rowL,clr,kit]]; exact hp.mode)), |
| le_rfl,heW,fun x hz=>?_⟩ |
| exact u.D.identity ((hw x i hz hi0).glad (t-j) (le_trans (Nat.sub_le _ _) (h0.trans hq))) |
| |
| lemma identityN {x:ℕ}(w:ℕ→ℕ→Tape): |
| (s.bank v f M k p w).scoreRank x= rank v.S0 (fun i=> M i x) s.k/(2:ℝ)^k:=by |
| let e:=s.beacon v f p |
| let g:=s.bank v f M k p w |
| let S:= Ember.Forest.S e x |
| let C:ℝ:=2^k; have hC:0<C:=by unfold C; positivity |
| let F:= fun i=> M i x/C |
| have hz : rank v.S0 F s.k =rank v.S0 (fun i=>M i x) s.k/C:=by |
| have hh:F=fun i=>C⁻¹*M i x:=funext (fun i=>by unfold F; ring) |
| rw [hh,scaled_rank (by positivity)]; ring |
| let l:= hp.M0.light |
| let j(i:ℕ):ℕ:=(token i).1 |
| have ha(i):i∈S → let a:=(token i).1; let b:=(token i).2 |
| a∈v.S0 ∧ f.awake a b ∧ f.locate a b=x ∧ g.V0 i=F a ∧ enc ((a,b):Rill.History)=i:=by |
| intro ht; obtain ⟨⟨a,b⟩,he,rfl⟩:=mem_image.1 ht |
| have hs:= (mem_filter.1 he).2 |
| change (coversF f a b).map _=some x at hs |
| simp only [token,dec_round] |
| unfold coversF at hs; split at hs |
| · next hc=> |
| have hi : f.locate a b=x:=Option.some.inj hs |
| refine ⟨(l.insured a b hc).1,hc,hi,?_,True.intro⟩ |
| change _=M a x/C; unfold Ember.Forest.V0; simp only [g,dec_round] |
| unfold scoreF; rw [ite_eq_left hc,hi] |
| contradiction |
| have h0(v0:ℝ)(hv:0 ≤ v0) : (S.filter fun i=>v0 < g.V0 i).card = |
| (v.S0.filter fun i=>v0 < F i).card:=by |
| let U:=S.filter fun i=>v0< g.V0 i |
| have he: U.image j=v.S0.filter fun i=>v0<F i:=by |
| ext i; constructor |
| · intro hl; obtain ⟨a,h1,rfl⟩:=mem_image.1 hl |
| obtain ⟨h1,h2⟩:=mem_filter.1 h1 |
| have he:=ha a h1; dsimp only at he |
| exact mem_filter.2 ⟨he.1,h2.trans_eq he.2.2.2.1⟩ |
| intro hv'; obtain ⟨hv',hh⟩:=mem_filter.1 hv' |
| have hC0:M i x≠0:=by intro hu; unfold F at hh; rw [hu,zero_div] at hh; linarith |
| obtain ⟨a,hp0,hb0⟩:= l.defend i x hC0 |
| let c:=hole i a |
| have hg:i∈u.D.P:=hp.plot.n0 hp.reg.chart hv' |
| have h0:c∈S:=mem_image.2 ⟨(i,a),mem_filter.2 |
| ⟨mem_product.2 ⟨hg,mem_range.2 (hp.M0.suit.lacks hg hp0)⟩,show (f.coversF i a).map _=some x from by |
| unfold coversF; rw [ite_eq_left hp0]; exact congrArg some hb0⟩,rfl⟩ |
| have hq0 := ha c h0 |
| have hp1 : token c=(i,a):= by unfold c hole token; simp |
| rw [hp1] at hq0; dsimp only at hq0 |
| exact mem_image.2 ⟨c,mem_filter.2 ⟨h0,hh.trans_eq hq0.2.2.2.1.symm⟩,by simp [j,hp1]⟩ |
| rw [← he]; symm |
| apply card_image_iff.mpr |
| intro i hi j1 hj hl |
| have hu1:=ha i (mem_filter.1 hi).1 |
| have hu2:=ha j1 (mem_filter.1 hj).1 |
| unfold j at hl |
| generalize heI : token i=x at * |
| generalize heJ : token j1=y at * |
| obtain ⟨i,i'⟩:=x; obtain ⟨j,j'⟩:=y; dsimp only at * |
| subst j |
| have hj:= l.fair _ _ _ hu1.2.1 hu2.2.1 (hu1.2.2.1.trans hu2.2.2.1.symm) |
| subst j'; exact hu1.2.2.2.2.symm.trans hu2.2.2.2.2 |
| have ht(v0)(he:0 ≤ v0) : (v0<g.scoreRank x) ↔ v0< rank v.S0 F s.k:=by |
| rw [Ember.Forest.scoreRank,rank_gt he,rank_gt he,h0 v0 he] |
| rw [← hz] |
| apply le_antisymm |
| · by_contra! hx |
| exact lt_irrefl _ ((ht _ (rank_nn ..)).1 hx) |
| by_contra! hx |
| exact lt_irrefl _ ((ht _ (rank_nn ..)).2 hx) |
| end Law |
| end Stand |
| end |
| end ExactDerandomization.SiteX.Line.Fabric |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.SiteX.Line.Fabric |
| open Counter Relay Rill Fret Chime Finset Grain Net Hie Est Analysis Stage Glass Plaza _root_.OAI.ExactDerandomization.Sub |
| open Helix Helix.Foil Helix.Age Helix.Moon Helix.Night Helix.Mold Helix.Orbit Scheme |
| open Dome Cone ConeX Buf At MintV Line Line.Fabric Producer Label |
| noncomputable section |
| open scoped Classical |
|
|
| variable {q w h:ℕ}{u:Line (q:=q) (w:=w) (h:=h)} |
| variable {v:Fabric u}{p:Producer}{κ:ℕ} |
| namespace Bloom12 |
| variable {l:ℕ→List Swirl.Gem}(ht:Bloom12 v p κ l) |
| include ht |
| theorem charm {o M pay}(hz:Certified p u (v.terminal false) M v.S0 v.S1 o pay)(ha:v.Mantle κ)(h:v.Good) |
| (hh:∀ i,u.D.Streams (v.slotWord i) ((v.alongE p κ).valueOf l (clim u.w0.p) i)): |
| ∃ tb:ℕ→ℕ→ℕ,v.Profession p tb:=by |
| let C:= v.alongE p κ |
| let T:=C.pie l clearG |
| have hp : u.D.Suite v.core12:= ht.quilt.h.supply |
| let K:=clim u.w0.p |
| have hl:= ht.mouth.fitL clearG u.D.cleared |
| have he(i)(x):∃ z,(z≠0→ p.awake x i ∧ z ≤ K)∧ |
| (p.awake x i→(z≠0↔ (flood v p (p.locate x i)).card ≤ K)) ∧ |
| (∀ j,0<j → j ≤ K → C.valueOf l K i j true x= if z=j then some (p.locate x i) else none):=by |
| let y:=p.locate x i |
| let F(j c:ℕ) := T.takes K i j x c |
| have hc (j c): C.valueOf l K i j true x=some c ↔ F j c:= ht.mouth.disp |
| have hh(j c)(he:F j c): p.awake x i∧ y=c:=by |
| have he:= hl.entry he |
| change (p.coversF x i).map Prod.snd=some c at he |
| unfold coversF at he; split at he |
| · next hw=> exact ⟨hw,Option.some.inj he⟩ |
| contradiction |
| by_cases hg:p.awake x i ∧ (flood v p y).card ≤ K |
| · obtain ⟨h0,h1⟩:=hg |
| have he:=(hz.light.insured x i h0) |
| have hm:y∈u.D.P:=Good.n1 ha.chart h he.2 |
| have hf:x∈u.D.P:=Good.n0 ha.chart h he.1 |
| rw [← ht.swell hz hm] at h1 |
| have hr:i<v.Rslots:=hz.suit.lacks hf h0 |
| have hL: pledge x i∈ l y:= by |
| change _ ∈ T.trace y |
| exact (hl.traceL hm).2 ⟨hf,hr,show (p.coversF x i).map _=some y by |
| rw [Producer.coversF,ite_eq_left h0]; rfl⟩ |
| obtain ⟨a,b,hg⟩:= List.mem_iff_append.mp hL |
| let j:=a.length+1 |
| have hP:F j y:=⟨hm,h1,a,b,hg,rfl⟩ |
| have hx:j ≤ K:=(Deck.rimmem hP.2.2).2.2.trans h1 |
| have ht1: j≠0:=by unfold j; omega |
| refine ⟨j,fun _=>⟨h0,hx⟩,fun _=>iff_of_true ht1 ?_, |
| fun i0 ho hk=>?_⟩ |
| · rw [← ht.swell hz hm]; exact h1 |
| split |
| · next hx=> subst i0; exact (hc j y).2 hP |
| next he0=> |
| cases hf:C.valueOf l K i i0 true x with |
| | none=>rfl |
| | some u=> have hv:=hl.agree hP ((hc i0 u).1 hf) |
| exact False.elim (he0 hv.2) |
| refine ⟨0,by simp,fun hw=>iff_of_false (by simp) (fun hf=>hg ⟨hw,hf⟩),fun j hr hi=>?_⟩ |
| rw [ite_eq_right (by omega)] |
| cases hk:C.valueOf l K i j true x with |
| | none=> rfl |
| | some t=> |
| have hu := (hc j t).1 hk |
| obtain ⟨ha,rfl'⟩:=hh j t hu |
| refine False.elim (hg ⟨ha,?_⟩) |
| rw [rfl',← ht.swell hz hu.1] |
| exact hu.2.1 |
| choose tb hb using he |
| refine ⟨fun x i=>tb i x, hp.stage,fun x i=> (hb i x).1,fun x i=>(hb i x).2.1, |
| fun x hx i hA t hB hS=>?_⟩ |
| have hs:=hh i |
| have hz' :u.D.dual (v.slotWord i) t:=(cap_dual hp).2 ⟨hA,hB,hS⟩ |
| exact ⟨hz',hs.canonicalS, (hs.lines hz' hx _).trans ((hb i x).2.2 t hB hS)⟩ |
| end Bloom12 |
|
|
| variable (v0:Tags) |
| def startsP {q w h:ℕ}(p:Rock q w h)(_:Word)(a:Plot):Bool:= |
| let g:=uphold (unitK a.1) |
| decide (operateR p.w (MV g) (Age.styx g)) |
| lemma startsK {q w h:ℕ}(p:Rock q w h):Kn (startsP p):=by |
| have hp:= ((Kn.unpack (α:=Crt)).comp unitK0).comp (Kn.first (β:=Site)) |
| exact GK.decideK (onRK p.w hp.right.right.left hp.right.left.left) |
| def quiet {q w h:ℕ}(p:Rock q w h)(A B:Cog):Cog:= |
| .bif ⟨_,startsK p⟩ A B |
| abbrev capprog {q w h:ℕ} (r:Rock q w h)(v:Tags)(p:Pose):Cog:=quiet r (Label.fullB r v p) Label.placeholder |
|
|
| lemma vocal (o g i t:ℕ)(f:Site):startsP u.r u.x (bell (v.c o g) i t,f)=true ↔ v.activeR:=by |
| unfold startsP; rw [bellU] |
| simp only [uphold,c,rowL,clr, Wire.eq,decide_eq_true_eq] |
| exact v.workR.symm |
| lemma rankName (i t o g:ℕ):who (bell (v.c o g) i t)=o:=by |
| unfold who; rw [bellU,ite_eq_right (show v.c o g ≠ 0 from Age.cpos _)] |
| simp [c,uphold,rowL,clr,kit] |
| |
| theorem tribunal {o M pay}(hz:Certified p u (v.terminal false) M v.S0 v.S1 o pay)(ha:v.Mantle κ) |
| (h:v.Good) (hp:u.D.Suite v.core12) (hr:u.D.Heard v.core12) (hx:v.activeR) |
| (hA:u.v.A*(2*u.v.A+40) ≤ u.v.slope) |
| (he:u.s.scripted 12 =capprog u.r u.v u.s.pave):∃ tb,v.Profession p tb:=by |
| let C:=v.alongE p κ |
| have h1:C.Trust:=ha.ties (by decide:¬Brole 10) (by omega) (by omega) true hz.suit hp hr |
| have hQ:C.Quilt:= |
| ⟨h1, ha.bridge true p hp.stage (Nat.zero_le _), rfl, rfl⟩ |
| obtain ⟨l,hL⟩:= hQ.quilted |
| have hT : Bloom12 v p κ l := ⟨hQ,⟨hL⟩⟩ |
| refine hT.charm hz ha h (hT.funded hA ha ?_) |
| intro i z b hX hz hZ a y hY |
| refine (Line.Chart.assigned (u := u)) hp.stage (bellU ..) ?_ |
| rw [v.rankName (o:=12)] |
| change Lot.Mane _ _ _ _ _ (u.s.scripted 12) _ _ |
| rw [he]; exact .yes ((v.vocal ..).2 hx) hY |
| |
| abbrev EmptyT :Dome.Tide:=fun _ _ _=>none |
| lemma desert12 (i:ℕ)(_:v.Good)(hk:¬v.activeR)(he:u.D.Suite v.core12)(ht:u.Chart) |
| (hg:u.s.scripted 12=capprog u.r u.v u.s.pave): u.D.Streams (v.slotWord i) EmptyT:=by |
| refine ⟨fun z hz x hx b q hq=>?_,fun _ _ _ _ _ _ hl=>by contradiction,fun _ _ _ _ _ _ _ _ hk _=>by contradiction⟩ |
| have hl:= Night.pairbill u.r u.v u.x u.prog (v.slotWord i) z hz b |
| have hD:u.D.D v.core12=1:=v.ageEnd _ (by decide) |
| let C:=u.v.slope |
| have hM : 6 ≤ C:=ht.above6 |
| have hm : u.D.pulseQ (v.slotWord i) z b ≤ u.D.F.limit:=hl |
| rw [v.adding] at hm ⊢ |
| let w:= (u.D.l.book (bell v.core12 (idx b i z) 0)) |
| let W:=u.D.W v.core12 |
| have hv:u.D.l.state C ⟨W,0⟩ (0,glove q x):=by |
| refine ⟨ht.e0.shape.account _ hx q hq,?_⟩ |
| change span C W 0 0 (lb 0+1); rw [lb_zero]; unfold span |
| have he:1 ≤ W:=hD ▸ he.well.2; nlinarith [Nat.mul_le_mul_left (C*C) he] |
| let Q:=bell v.core12 (idx b i z) 0 |
| have he0 :Lot.Mane u.D.l C ⟨W,0⟩ (u.D.D v.core12) Q (u.s.scripted 12) (0,glove q x) (0,glove q x):=by |
| rw [hg] |
| apply Lot.Mane.no |
| · have hh : ¬ startsP u.r u.x (Q,(0,glove q x))=true:=mt (v.vocal ..).1 hk |
| change startsP u.r u.x (Q,0,glove q x)=false; simpa using hh |
| exact .edit rfl hv hv |
| have hm1: Lot.Mane u.D.l C ⟨W,0⟩ (u.D.D v.core12) Q u.D.l.P (0,glove q x) (0,glove q x):=by |
| apply (Line.Chart.assigned (u := u)) he.stage (bellU ..) |
| rw [v.rankName] |
| exact he0 |
| exact he.hired _ 0 hm (by change 1 ≤ C;omega) le_rfl hm1 |
| |
| end |
| end ExactDerandomization.SiteX.Line.Fabric |
| |
| end |
| |
| section |
| |
| namespace ExactDerandomization.SiteX.Line.Fabric |
| open Counter Relay Rill Fret Chime Finset Grain Net Hie Est Analysis Stage Glass Plaza _root_.OAI.ExactDerandomization.Sub |
| open Helix Helix.Foil Helix.Age Helix.Moon Helix.Night Helix.Mold Helix.Orbit Scheme |
| open Dome Cone ConeX Buf At MintV Line Line.Fabric Producer Label Ember.Forest |
| noncomputable section |
| open scoped Classical |
| |
| variable {q w h:ℕ}{u:Line (q:=q) (w:=w) (h:=h)} |
| namespace Stand |
| variable (s:Stand) |
| def score0 (p:Rock q w h)(k:Tags)(g:Pose):Cog:= |
| let b:=roadX p k false s.i s.l s.o |
| let v:= coneX p g |
| let w:PowerTop:= ⟨_, Label.putK p k⟩ |
| renbody (liftarm (Ember.Forest.trackG v b (schedule p k) k.A w s.k)) |
| abbrev tollD (u : Line (q:=q) (w:=w) (h:=h)) :=powder (u.v.A*(2*u.v.A+40)+6*(s.k+50)) |
| namespace Law |
| variable {s k v f p M}(hp:s.Law (u:=u) v f p k M) |
| include hp |
|
|
| set_option maxHeartbeats 1000000 in |
| theorem ardent (hc:s.tollD u ≤ u.v.slope)(hq:s.a=13∨s.a=16) |
| (hl:u.s.scripted s.a=s.score0 u.r u.v u.s.pave){x}(hx:x∈u.D.P): |
| u.D.Voice (v.c s.a 0) x (hole 1 0) (s.H v) k (rank v.S0 (fun i=> M i x) s.k):=by |
| obtain ⟨f0,hA⟩:=hp.promoted |
| let q:=s.bank v f M k p f0 |
| have ht := hA.fullplan hx; let e:=s.beacon v f p; let j:=v.c s.a 0 |
| let F:= q.scoreTape x |
| have hs: Checked F (q.scoreRank x) q.H:=hA.estimated x |
| refine ⟨F,⟨?_,?_⟩⟩ |
| · rw [← hp.identityN f0]; exact hs |
| intro t he b hb |
| let y:=(e.D.orch e.u x e.slotv) |
| have hp0 :Dome.glove b x ≤ u.D.F.limit:=hp.auth.shape.account _ hx b hb |
| have hn:(s.cage v).visN=v.c s.i 0:=rfl |
| obtain ⟨hg,hB⟩:= ht (Dome.glove b x) ⟨_,hb,rfl⟩ |
| let c:=enc (dsign F t) |
| have hC := hB.digits t he |
| let r:=post j 1 0 t |
| have hlQ: u.smallQ j 0:=by |
| have hh:1 ≤ u.eye.e:= le_trans (by omega) hp.M0.suit.coil.baseC |
| unfold Line.smallQ ConeX.wideQ; rw [lb_zero] |
| have he1:= hp.auth.well.1 |
| change 1 ≤ u.eye.e*u.D.D j; change 0< u.D.D j at he1; nlinarith |
| have hw : Lot.Mane u.D.l (s.tollD u) ⟨u.D.W j,t⟩ (u.D.D j) r (u.s.scripted s.a) |
| (0,glove b x) (c,glove b x):=by |
| rw [hl]; unfold score0 |
| change Lot.Mane u.D.l (s.tollD u) ⟨u.D.W j,t⟩ (u.D.D j) (post j 1 0 t) (renbody q.engine) (0,glove b x) (c,glove b x) |
| have he0: Label.substitute u.x (post j 1 0 t) = post j Label.PURE 0 t:=by simp only [substitute,bellT,bellU,post] |
| apply reprise (u:=post j Label.PURE 0 t) ?_ (show Label.substitute u.D.l.x _=_ from he0) |
| exact hC |
| have hR: who r=s.a:= rankName (v:=v) _ _ s.a 0 |
| have hy: Lot.Mane u.D.l (s.tollD u) ⟨u.D.W j,t⟩ (u.D.D j) r u.D.l.P |
| (0,glove b x) (c,glove b x):=by |
| apply (Line.Chart.assigned (u := u)) hp.auth.stage (bellU ..) |
| rw [hR] |
| unfold codeRank |
| rw [ite_eq_right (by omega),ite_eq_right (by omega)] |
| exact hw |
| exact hp.auth.hired _ t (u.Launch hp.auth.stage 0 1 t hlQ (by omega) he) |
| (by unfold tollD powder; omega) hc hy |
| end Law |
| |
| abbrev TDef (k:ℕ) :Stand:=⟨13,11,9,4,3,k⟩ |
| abbrev IDef (k:ℕ) :Stand:=⟨16,15,14,1,0,k⟩ |
|
|
| end Stand |
| end |
| end ExactDerandomization.SiteX.Line.Fabric |
|
|
| end |
|
|
| end OAI |
|
|
