| import OAI.Computability.Logspace.EstimatorMachine |
|
|
| namespace OAI |
|
|
| /-! |
| Finite iteration schedules and the decomposition of estimator increments. |
|
|
| From OpenAI, *Exact Derandomization of Logarithmic Space: L = RL = BPL*. |
| -/ |
|
|
| set_option autoImplicit true |
|
|
| section |
|
|
| namespace ExactDerandomization.Rain |
| 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 SiteX SiteX.MintV |
| noncomputable section |
|
|
| /- Enumerate the increments by a pool in which each piece of a telescope, |
| variant of the walk, and multiplicand port have one reserved index. -/ |
| abbrev Crack:= Bool×ℕ |
| abbrev CellQ:= Crack × (ℕ×ℕ) |
| abbrev Fog := (Bool×CellQ) × (Bool×ℕ) |
| abbrev Seed := (ℕ× ℕ×ℕ) × Fog |
| abbrev store0 (_:Word)(x:ℕ):Seed:=dec x |
| namespace Fog |
| abbrev first0 (q:Fog):Bool:=q.1.1 |
| abbrev cell0 (q:Fog):= q.1.2 |
| abbrev sig (q:Fog) := q.cell0.2.2 |
| abbrev event (q:Fog):= q.2.2 |
| abbrev k (q:Fog)(a:ℕ):= if q.cell0.1.1 then a+q.cell0.1.2 else a-q.cell0.1.2 |
| abbrev ray (q:Fog)(a:ℕ):ℕ×ℕ:= (q.k a,q.cell0.2.1) |
| abbrev slackM (q:Fog)(M:ℕ):= M-q.sig-1 |
| abbrev budget (q:Fog)(M:ℕ) := if q.2.1 then q.slackM M+1 else q.slackM M |
| abbrev tick (q:Fog)(v:Wares):=v.ell*q.sig |
|
|
| def habitat (q:Fog)(w:Wares)(a m i:ℕ)(forest:Finset Ray):Prop:= |
| let p:=q.ray a |
| let s:Est.Stair:=⟨m,0,⟨a,0,0⟩,w.ell⟩ |
| p∈forest ∧ q.slackM m ∈ s.layers p.1 i ∧ s.slack (q.slackM m)=q.sig ∧ |
| q.cell0.1=(if a ≤ p.1 then (true,p.1-a) else (false,a-p.1)) ∧ |
| q.event<Print.rad^(q.tick w) |
| def number0 (s: Stair)(b:Bool) (k:Ray) (m:ℕ)(a:Bool)(i:ℕ):Fog:= |
| let v:=s.key.a |
| (((b,(if v ≤ k.1 then (true,k.1-v) else (false,v-k.1)),k.2,s.slack m)),a,i) |
| lemma from0 (s:Stair)b r m v i: |
| (number0 s b r m v i).ray s.key.a=r := by |
| refine Prod.ext ?_ rfl |
| unfold ray k number0 cell0; dsimp only; split <;> simp_all ; omega |
|
|
| lemma just (s:Stair)(p:Ray)(m:ℕ):s.layers p.1 m = |
| Est.Stair.layers ⟨s.M,0,⟨s.key.a,0,0⟩,s.lam⟩ p.1 m := by |
| cases m <;> rfl |
| lemma hews {s:Stair} {w:Wares}(hp:s.lam=w.ell) (b:Bool) {p:Ray}{forest:Finset Ray}(he:p∈forest) |
| {i m:ℕ}(hm:m∈s.layers p.1 i)(a:Bool) {j:ℕ}(hj:j<Print.rad^(s.lam*s.slack m)): |
| (number0 s b p m a j).habitat w s.key.a s.M i forest ∧ (number0 s b p m a j).slackM s.M=m:=by |
| let q:= number0 s b p m a j |
| have h:s.gap i ≤ s.slack m ∧ s.cut p.1 ≤ s.slack m ∧m+1<s.M := s.cheap (mem_Ico.1 hm).2 |
| have hd:q.slackM s.M=m:=by unfold q number0 slackM Stair.slack; have hh:= h.2.2; dsimp [sig,cell0]; omega |
| refine ⟨?_,hd⟩ |
| let a0:=s.key.a |
| let n:Stair:=⟨s.M,0,⟨a0,0,0⟩,w.ell⟩ |
| have hZ := just s p i |
| rw [hp] at hZ hj |
| have hh:q.ray a0=p:=from0 .. |
| have hf:q.k a0=p.1:=congrArg Prod.fst hh |
| change q.ray a0∈forest ∧ q.slackM s.M∈n.layers (q.k a0) i∧ n.slack (q.slackM s.M)=q.sig∧ |
| q.cell0.1=(if a0≤ q.k a0 then _ else _)∧ q.event<_ |
| refine ⟨hh.symm ▸ he,?_,?_,?_,hj⟩ |
| · rw [hf,hd]; exact hZ ▸ hm |
| · rw [hd]; rfl |
| change q.cell0.1=(if a0 ≤ q.k a0 then (true,q.k a0-a0) else (false,a0-q.k a0)); rw [hf]; rfl |
|
|
| lemma totally {s:Stair}{w:Wares}(_:s.lam=w.ell){i:ℕ}{forest:Finset Ray} |
| {q:Fog}(h:q.habitat w s.key.a s.M i forest): |
| let p:=q.ray s.key.a |
| p∈forest ∧ q.slackM s.M∈s.layers p.1 i ∧ |
| number0 s q.first0 p (q.slackM s.M) q.2.1 q.event=q :=by |
| dsimp only; refine ⟨h.1,?_,?_⟩ |
| · rw [just s (q.ray s.key.a) i]; exact h.2.1 |
| obtain ⟨hj,hk,hC⟩:=h.2.2 |
| dsimp only [number0]; change q.cell0.1=(if s.key.a ≤ q.k s.key.a then (true,q.k s.key.a-s.key.a) else (false,s.key.a-q.k s.key.a)) at hk; rw [← hk,show s.slack _=q.sig from hj] |
|
|
| lemma far0 {s:Stair} {w:Wares}(hp:s.lam=w.ell){i:ℕ}(hi:i<s.L){forest:Finset Ray}{q:Fog} |
| (h:q.habitat w s.key.a s.M i forest): |
| q.cell0.1.2 ≤ 2*s.gap i ∧ s.gap i ≤ q.sig∧ q.sig< 2*s.gap i:=by |
| let r:=q.ray s.key.a; let m:=q.slackM s.M |
| have hm:m∈s.layers r.1 i:= (totally hp h).2.1 |
| have hr :s.slack m=q.sig:=h.2.2.1 |
| have h0:=s.full hm hi |
| have he :distn s.key.a r.1+1 ≤ s.slack m:= (s.cheap (mem_Ico.1 hm).2).2.1 |
| have hu:q.cell0.1.2 ≤ distn s.key.a r.1:= by |
| rw [show q.cell0.1=(if s.key.a ≤ r.1 then (true,r.1-s.key.a)else(false,s.key.a-r.1)) from h.2.2.2.1] |
| unfold distn; split <;> dsimp only <;> omega |
| omega |
| end Fog |
| namespace Seed |
| abbrev fog:(Seed)→ Fog:=Prod.snd |
| abbrev x (v:Seed):ℕ:= v.1.2.1 |
| abbrev y (v:Seed):ℕ:=v.1.2.2 |
| def old (b:Bool)(i:ℕ):Seed:=((if b then 0 else 1,i,0),(false,(true,0),0,0),false,0) |
| def along (v:Fog)(i j:ℕ):Seed:= ((2,i,j),v) |
| lemma old_inj {b c i j}: Seed.old b i=Seed.old c j ↔ b=c∧i=j:=by |
| cases b <;> cases c <;> simp [Seed.old] |
| lemma along_inj {q f i j a b}: along q i j=along f a b ↔ q=f∧i=a∧j=b:=by simp [along]; tauto |
| lemma old_not (p i j q v):old p i ≠ along q j v:=by cases p <;> simp [old,along] |
| end Seed |
|
|
| abbrev CarryE(p:Wares) :ℕ:= cexpo 2 p.p.K *4 |
| def passport (v:Wares):ℕ:= 50+v.p.M^2+v.p.K+2*v.p.M+4*CarryE v+2*v.ell*lb Print.rad |
|
|
| namespace Pass |
| variable (v:Wares) |
| lemma small {p d i j:ℕ}(h:p ≤ i*d)(he:i ≤ j):p ≤ j*d:=le_trans h (Nat.mul_le_mul_right d he) |
| abbrev sized {α} [Wire α] (u:α)(k d:ℕ):= lb (enc u) ≤ k*d |
| lemma pair {α β} [Wire α] [Wire β] {p:α}{q:β}{c d:ℕ}(h:1 ≤ d)(hc:2 ≤ c) |
| (hp:sized p c d)(hq:sized q c d):sized (p,q) (4*c) d:=by |
| have he:lb (enc (p,q)) ≤ 2*lb (enc p)+lb (enc q)+2:=measure_pair .. |
| unfold sized at *; nlinarith |
| lemma little (p d:ℕ)(h:1 ≤ d):sized p (p+1) d:=by |
| change lb p ≤ _; have := lb_le_inc p; nlinarith |
| lemma left {α} [Wire α] (p:α)(k d:ℕ)(h:sized p k d) (c:ℕ)(hp:k ≤ c):sized p c d:=small h hp |
| lemma boo (p:Bool)(k d:ℕ)(he:1 ≤ k)(hp:1 ≤ d):sized p k d:=by |
| unfold sized |
| have h: lb (enc p)=1:=by cases p<;> rfl |
| rw [h]; nlinarith |
| abbrev reserve (v:Wares):=4^7 *passport v |
| lemma lengthC {s:Stair} {i:ℕ}(hp:s.lam=v.ell)(hi:i<s.L){forest:Finset Ray} |
| (h:∀ q∈forest,q.2 ≤ v.p.M^2+2*v.p.M+2){q:Fog}(hq:q.habitat v s.key.a s.M i forest) {p r:ℕ} |
| (he:p ≤ v.p.K)(ht:r ≤ v.p.K):sized (Seed.along q p r) (reserve v) (s.gap i):=by |
| let c:=passport v; let d:=s.gap i |
| have hc:c≥50:=by unfold c passport; omega |
| have hd:d ≥ 1:=gapD_pos .. |
| have hz:q.cell0.2.1 ≤ v.p.M^2+2*v.p.M+2:=h (q.ray s.key.a) hq.1 |
| obtain ⟨hm,hL,hs⟩:= Fog.far0 hp hi hq |
| have hK : lb (enc q.event) ≤ c*d:=by |
| have hr:q.event< Print.rad^ (v.ell*q.sig):=hq.2.2.2.2 |
| have hh:Print.rad ≤ 2^lb Print.rad:= (below _).le |
| have hv:q.event<2^(c*d):= hr.trans_le (le_trans (Nat.pow_le_pow_left hh _) (by |
| rw [←pow_mul]; apply Nat.pow_le_pow_right (by omega) |
| let L:= lb Print.rad |
| have he: 2*v.ell*L ≤ c:=by unfold L; unfold c passport; omega |
| change q.sig < 2*d at hs |
| change L*(v.ell*_) ≤ _ |
| nlinarith [Nat.mul_le_mul_left (L*v.ell) hs.le,Nat.mul_le_mul_right d he])) |
| exact modest hv (by nlinarith) |
| have hC(x:ℕ)(hi:x+1 ≤ c):sized x c d:= left x _ d (little x d hd) c hi |
| have hl(x:ℕ)(hi:x ≤ 2*d):sized x c d:=by change lb x ≤ _; have := lb_le_inc x; nlinarith |
| have hA:sized q.cell0.1 (4*c) d:=pair hd (by omega) (boo _ _ _ (by omega) hd) (hl _ hm) |
| have hB:sized q.cell0.2 (4*c) d:=pair hd (by omega) |
| (hC q.cell0.2.1 (by unfold c passport; omega)) (hl q.sig hs.le) |
| have hv:sized q.cell0 (4*(4*c)) d:= pair hd (by omega) hA hB |
| have hw:sized q.1 (4*(4*(4*c))) d:=pair hd (by omega) (boo _ _ _ (by omega) hd) hv |
| have hq1:sized q (4*(4*(4*(4*c)))) d:=pair hd (by omega) hw (pair hd (by omega) |
| (boo _ _ _ (by omega) hd) (left _ c d hK _ (by omega))) |
| have hi:sized (2,p,r) (4*(4*c)) d:= by |
| refine pair hd (by omega) (left (2:ℕ) c d (hC 2 (by omega)) (4*c) (by omega)) (pair hd (by omega) (hC _ ?_) (hC _ ?_)) |
| all_goals unfold c passport; omega |
| exact left (Seed.along q p r) _ d (pair hd (by omega) (left _ _ d hi _ (by omega)) hq1) |
| _ (by unfold reserve; change _ ≤ _ * c; omega) |
| end Pass |
| end |
| end ExactDerandomization.Rain |
|
|
| end |
| |
| section |
|
|
| namespace ExactDerandomization.Rain |
| 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 SiteX SiteX.MintV Fog Env |
| noncomputable section |
| open scoped Classical |
|
|
| variable {n:ℕ} [Fact n.Prime] |
| /- Iteration radii by slack chart. -/ |
| namespace Census |
| variable (s:Stair) |
| abbrev h(i) := s.lam*s.slack i |
| def calendar (m:ℕ) := ((Finset.univ:Finset Bool)×ˢ (range (Print.rad^h s m))) |
| def tracks (p:Finset Ray)(i:ℕ) := p.biUnion (fun q=>{q}×ˢ ((s.layers q.1 i).biUnion |
| fun m=>{m}×ˢ calendar s m)) |
| abbrev Arc:= Ray × ℕ × Bool×ℕ |
| lemma pat (p:Finset Ray)(i:ℕ)(x:Arc): x∈tracks s p i ↔ |
| x.1∈p∧ x.2.1∈s.layers x.1.1 i∧ x.2.2.2< Print.rad^h s x.2.1:=by |
| unfold tracks calendar |
| rcases x with ⟨a,b,c,d⟩; cases c <;> simp [and_assoc,and_left_comm,and_comm] |
| def drops (b:Bool)(q:Arc):Fog:= number0 s b q.1 q.2.1 q.2.2.1 q.2.2.2 |
| lemma grange {w:Wares}(ht:s.lam=w.ell)(b:Bool){x:Arc}{p i}(h:x∈tracks s p i): |
| (drops s b x).habitat w s.key.a s.M i p∧ (drops s b x).ray s.key.a=x.1 ∧ |
| (drops s b x).slackM s.M=x.2.1:=by |
| obtain ⟨hl,hA,hQ⟩:= (pat s p i x).mp h |
| obtain ⟨hz,hf⟩:=hews ht b hl hA x.2.2.1 hQ |
| exact ⟨hz,from0 ..,hf⟩ |
|
|
| lemma disjoint0 {w:Wares}(ht:s.lam=w.ell) (b p i):Set.InjOn (drops s b) ↑(tracks s p i):= by |
| intro x hx y hy he |
| have h1:=grange s ht b hx; have h2:=grange s ht b hy |
| have ha:x.1=y.1:= h1.2.1.symm.trans ((congrArg (fun x=> ray x s.key.a) he).trans h2.2.1) |
| have hb:x.2.1=y.2.1:= h1.2.2.symm.trans ((congrArg (fun x=> slackM x s.M) he).trans h2.2.2) |
| have hc:x.2.2=y.2.2:=congrArg (fun q:Fog=>q.2) he |
| exact Prod.ext ha (Prod.ext hb hc) |
| lemma total (p:Finset Ray) (i:ℕ) (f:Arc→ℝ): |
| ∑ x∈tracks s p i,f x= |
| ∑ x∈p,∑ m∈s.layers x.1 i,∑ j∈range (Print.rad^(h s m)),∑ b:Bool,f (x,m,b,j):=by |
| unfold tracks |
| rw [sum_biUnion] |
| · apply sum_congr rfl; intro x hx |
| rw [sum_product]; simp only [sum_singleton] |
| rw [sum_biUnion] |
| · apply sum_congr rfl; intro m hm; rw [sum_product] |
| simp only [sum_singleton]; unfold calendar; rw [sum_product,sum_comm] |
| intro i hi j hj ht; apply Finset.disjoint_left.2 |
| intro a ha hc; simp only [mem_product,mem_singleton] at ha hc; grind |
| intro i hi j hj ht; apply Finset.disjoint_left.2 |
| intro a ha hc; simp only [mem_product,mem_singleton] at ha hc; grind |
|
|
| def wind (f:Est.Flame n)(d:Axis)(u:Pool n)(x y:ℕ)(r:Arc):ℝ:= |
| let t:= Print.queue (h s r.2.1) r.2.2.2 |
| if Env.live d.u d.a (↑x:ZMod n) (↑y:ZMod n) (w:=0) (d:=0) le_rfl t.1 t.2 u then |
| (if r.2.2.1 then 1 else -1)*Env.weight^(h s r.2.1)* |
| (f.lines r.1).seq (if r.2.2.1 then r.2.1+1 else r.2.1) |
| (go d.u d.a (w:=0) (d:=0) le_rfl t.1 t.2 u) x y |
| else 0 |
|
|
| theorem humid (f:Flame n)(d:Axis)(i:ℕ)(u:Pool n)(x y:ℕ) : |
| f.portion s d i u x y=(∑ j∈tracks s f.rays i,wind s f d u x y j)+ |
| if i=0 then f.base x y else 0 :=by |
| rw [total] |
| unfold Flame.portion |
| apply congrArg (fun (p:ℝ)=>p+_) |
| apply sum_congr rfl; intro j hj; unfold Est.Line.waveR |
| apply sum_congr rfl; intro m hm |
| unfold Est.Line.pick Axis.fw Env.sampling |
| rw [← Print.touring] |
| apply sum_congr rfl; intro p hp |
| simp only [Fintype.sum_bool] |
| unfold wind |
| let v:= Print.queue (h s m) p |
| dsimp only |
| unfold Est.Line.shake h |
| split |
| · next hx=> simp only [ite_true,Bool.false_eq_true,ite_false]; ring |
| next hc=>ring |
| end Census |
|
|
| end |
| end ExactDerandomization.Rain |
|
|
| end |
| |
| end OAI |
|
|
