| import OAI.Computability.Logspace.RecursivePrograms |
|
|
| namespace OAI |
|
|
| /-! |
| Catalytic comparison of encoded identifiers and bounded traversal operations. |
|
|
| From OpenAI, *Exact Derandomization of Logarithmic Space: L = RL = BPL*. |
| -/ |
|
|
| set_option autoImplicit true |
|
|
| section |
|
|
| /-! Deterministic catalytic ID comparisons. B logarithmic is raw code-bit |
| bound for the ids. Work simultaneously active still controlled by the |
| priced Bout stack. -/ |
| namespace ExactDerandomization.Glass |
| open Relay Counter Finset |
| namespace NatD |
|
|
| abbrev dig (b a k:ℕ) := a/b^k % b |
| def record (b:ℕ) (z:ℕ→ℕ)(k:ℕ):ℕ:= forNat (fun j a=> a+z j*b^j) 0 k |
| lemma next (b z k): record b z (k+1)=record b z k+z k*b^k := rfl |
| lemma under {b z k}(h:∀ j<k,z j<b): record b z k<b^k:=by |
| induction k with |
| | zero=> simp [record,forNat] |
| | succ k ih=> |
| have hz:=ih (fun j hj=>h j (by omega)) |
| have hv:=h k (by omega) |
| rw [next,pow_succ,mul_comm (b^k)] |
| have hx:=Nat.mul_le_mul_right (b^k) (show z k+1≤b from hv) |
| nlinarith |
| lemma letter {b z k} (hb:2≤b) (h:∀ j<k,z j<b) {j:ℕ}(he:j<k): |
| dig b (record b z k) j=z j := by |
| induction k with |
| | zero=>omega |
| | succ k ih=> |
| have hz:=under (b:=b) (k:=k) (fun j hj=> h j (by omega)) |
| have hs:0 < b^j:=Nat.pow_pos (by omega) |
| by_cases hu:j=k |
| · subst j |
| unfold dig; rw [next,Nat.add_mul_div_right _ _ hs,Nat.div_eq_of_lt hz,zero_add,Nat.mod_eq_of_lt (h _ he)] |
| unfold dig; rw [next] |
| have hk : b^k=b^(k-(j+1))*b*b^j:=by |
| rw [←pow_succ,←pow_add]; rw [show k-(j+1)+1+j=k by omega] |
| rw [hk,show z k*(b^(k-(j+1))*b*b^j)=z k*b^(k-(j+1))*b*b^j by ring, |
| Nat.add_mul_div_right _ _ hs,Nat.add_mul_mod_self_right] |
| exact ih (fun j hz=>h j (by omega)) (by omega) |
|
|
| lemma record_mod (b x k:ℕ) (hb:2≤b) : record b (dig b x) k = x%(b^k):= by |
| induction k with |
| | zero=>simp [record,forNat]; omega |
| | succ k ih=> |
| rw [next,ih,pow_succ] |
| have hk : 0 < b^k:=Nat.pow_pos (by omega) |
| rw [Nat.mod_mul] |
| dsimp [dig]; ring |
| lemma equal {b k x y:ℕ}(hb:2≤b)(hx:x<b^k)(hy:y<b^k) |
| (h:∀ i<k,dig b x i=dig b y i) : x=y:= by |
| have he : ∀ j≤k, record b (dig b x) j=record b (dig b y) j:=by |
| intro j hj; induction j with |
| | zero=>rfl |
| | succ j ih=> rw [next,next,ih (by omega),h _ (by omega)] |
| have ht:=he k le_rfl; simpa [record_mod _ _ _ hb,Nat.mod_eq_of_lt hx,Nat.mod_eq_of_lt hy] using ht |
|
|
| lemma dial_eq {b x k} (_:0<b):x/min (x+1) (b^k)=x/(b^k):=by |
| by_cases he:b^k≤x+1 |
| · rw [min_eq_right he] |
| rw [min_eq_left (by omega),Nat.div_eq_of_lt (by omega),Nat.div_eq_of_lt (by omega)] |
| lemma digK {α} [Wire α] {b x k:PT α ℕ}(h:Kn b)(e:Kn x)(f:Kn k): |
| Kn (fun w a=> dig (b w a) (x w a) (k w a)):=by |
|
|
| convert (e.div (Kn.cap e.succ h f)).mod h using 1 |
| ext w a |
| by_cases he:b w a=0 |
| · unfold dig; rw [he] |
| cases k w a <;> simp |
| unfold dig; rw [dial_eq (by omega)] |
| end NatD |
|
|
| structure Rod where |
| peak :ℕ |
|
|
| namespace Rod |
| variable (p:Rod) |
| def B:=lb p.peak |
| def e:=lb p.B |
| def n:=2^p.e |
| def L:=p.B/p.e+1 |
| def M:=p.n^4 |
| def F:=p.M^p.L |
| def Q:= (2:ℕ)^p.n |
| lemma b0 :0< p.B:=lb_pos _ |
| lemma e0 :0< p.e:=lb_pos _ |
| lemma e2: p.e ≤ 2*p.B:=by |
| have h:=p.b0; have he:=lb_le_inc p.B |
| change lb p.B≤_; omega |
| lemma n2:2 ≤ p.n:=by |
| have h:=p.e0; simpa [n] using Nat.pow_le_pow_right (n:=2) Nat.zero_lt_two (show 1≤p.e from h) |
| lemma n_hi:p.B< p.n:=below _ |
| lemma n_low: p.n≤ 2*p.B:=above p.b0 |
| lemma L_le:p.L≤p.n:=by |
| have he:=p.n_hi; unfold L; have hx:=Nat.div_le_self p.B p.e; omega |
| lemma L_price:p.e*p.L ≤ 3*p.B ∧ p.B ≤ p.e*p.L:=by |
| unfold L; rw [left_distrib] |
| have he:= p.e2; have ht:= Nat.mod_add_div p.B p.e; have hk:=Nat.mod_lt p.B p.e0 |
| omega |
| lemma coded {x}(h:x≤p.peak): x< p.n^p.L:= by |
| have hz:= Nat.pow_le_pow_right (n:=2) Nat.zero_lt_two p.L_price.2 |
| unfold n; rw [←pow_mul] |
| exact lt_of_le_of_lt h ((below _).trans_le hz) |
| lemma M4 :4≤p.M:= by |
| have he:=Nat.pow_le_pow_left p.n2 4 |
| exact le_trans (by norm_num) he |
| lemma costs : p.F≤caplen p.peak ^ 12:=by |
| have ht:=p.L_price.1 |
| unfold F M n caplen |
| change ((2^p.e)^4)^p.L ≤ (2^p.B)^12 |
| rw [←pow_mul,←pow_mul,←pow_mul]; apply Nat.pow_le_pow_right (by omega) |
| nlinarith |
| lemma costs2: p.Q≤caplen p.peak ^ 2:=by |
| have he:=p.n_low |
| unfold Q caplen; rw [←pow_mul] |
| exact Nat.pow_le_pow_right Nat.zero_lt_two (show p.n ≤ p.B*2 by omega) |
| end Rod |
| end ExactDerandomization.Glass |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Glass |
| open Relay Counter Finset NatD |
|
|
| def shove (m:ℕ)(b:Bool)(x y:ℕ):ℕ := |
| if b then (x+y)%m else (x+m-y%m)%m |
| lemma enoughS {m y x} (b:Bool)(he:0< m): shove m b x y< m:=by |
| unfold shove; split <;> exact Nat.mod_lt _ he |
|
|
| namespace Rod |
| variable (p:Rod) |
| instance nzM : NeZero p.M:=⟨Nat.ne_of_gt (by have:=p.M4; omega)⟩ |
| private lemma equals {x y:ℕ}(hx:x < p.M)(hy:y < p.M) |
| (h:(x:ZMod p.M)=(y:ZMod p.M)) : x=y := by |
| have he:=congrArg ZMod.val h |
| simpa [ZMod.val_natCast,Nat.mod_eq_of_lt hx,Nat.mod_eq_of_lt hy] using he |
| lemma cast_shove (b x y) : |
| (shove p.M b x y:ZMod p.M) = |
| if b then (x:ZMod p.M)+y else (x:ZMod p.M)-y := by |
| unfold shove; have hm : y%p.M ≤ x+p.M:=by |
| have hr:=Nat.mod_lt y (le_trans (by omega :1≤4) p.M4); omega |
| cases b <;> simp [Nat.cast_sub hm] |
| lemma cancel (b i j) (hi:i < p.M) : shove p.M (!b) (shove p.M b i j) j =i:= by |
| refine p.equals (enoughS _ (by have:=p.M4; omega)) hi ?_ |
| simp_rw [p.cast_shove]; cases b <;> simp |
|
|
| def mix (b:Bool) (u x:ℕ) := |
| record p.M (fun i=>shove p.M b (dig p.M u i) (dig p.n x i)) p.L |
| lemma pigment (b u x):p.mix b u x < p.F:= by |
| unfold mix F; apply under; intro i _ |
| apply enoughS; have := p.M4; omega |
| lemma component (b u x) {i} (he:i < p.L): |
| dig p.M (p.mix b u x) i=shove p.M b (dig p.M u i) (dig p.n x i):= by |
| have h:=p.M4 |
| unfold mix |
| exact letter (by omega) (fun j hj=> enoughS _ (by omega)) he |
| lemma opposite {u}(b x)(hi:u < p.F):p.mix (!b) (p.mix b u x) x=u := by |
| have h:=p.M4 |
| apply equal (by omega:2 ≤ p.M) (p.pigment ..) hi |
| intro i hi |
| rw [p.component _ _ _ hi,p.component _ _ _ hi] |
| apply p.cancel; exact Nat.mod_lt _ (by omega) |
|
|
| def hinge (x y:ℕ):=∑ i∈ range p.L, dig p.n x i*dig p.n y i |
| def aloft (u x:ℕ):=∑ i∈range p.L,dig p.M u i*dig p.n x i |
|
|
| lemma twist (u x y): |
| (p.aloft (p.mix true u x) y:ZMod p.M)= ↑(p.aloft u y)+↑(p.hinge x y) := by |
| unfold aloft hinge; push_cast |
| rw [← sum_add_distrib] |
| apply sum_congr rfl; intro i hi |
| rw [p.component _ _ _ (mem_range.1 hi),p.cast_shove,ite_eq_left rfl,add_mul] |
|
|
| abbrev Pane := ℕ×ℕ×ℕ |
| def proper (v:Pane):=v.1 < p.F ∧ v.2.1 < p.M ∧ v.2.2 < p.Q |
|
|
| def first (b:Bool)(x:ℕ)(v:Pane):Pane := |
| (p.mix b v.1 x, shove p.M b v.2.1 (p.hinge x x),v.2.2) |
| def second (b:Bool)(y:ℕ)(v:Pane):Pane := |
| (v.1,shove p.M (!b) (shove p.M b v.2.1 (p.hinge y y)) (2*p.aloft v.1 y), v.2.2) |
| def pointR (b:Bool)(x:ℕ)(v:Pane):Pane:= (p.mix (!b) v.1 x,v.2) |
| def pointZ (b:Bool)(x:ℕ)(v:Pane):Pane := (v.1, shove p.M b v.2.1 (2*p.aloft v.1 x),v.2.2) |
|
|
| lemma stay (b x) {v}(h:p.proper v): p.proper (p.first b x v) ∧ p.proper (p.second b x v) ∧ |
| p.proper (p.pointR b x v) ∧ p.proper (p.pointZ b x v):=by |
| have hM:=p.M4; have he:0< p.M:=by omega |
| exact ⟨⟨p.pigment ..,enoughS _ he,h.2.2⟩,⟨h.1,enoughS _ he,h.2.2⟩, |
| ⟨p.pigment ..,h.2⟩,⟨h.1,enoughS _ he,h.2.2⟩⟩ |
| lemma negone (b x) {v:Pane}(h:p.proper v): |
| p.first (!b) x (p.first b x v)=v ∧ p.second (!b) x (p.second b x v)=v ∧ |
| p.pointR (!b) x (p.pointR b x v)=v ∧ p.pointZ (!b) x (p.pointZ b x v)=v :=by |
| obtain ⟨v,z,Q⟩:=v |
| have hM:=p.M4 |
| have hs(v w i):shove p.M v w i< p.M:=enoughS _ (by omega) |
| refine ⟨?_,?_,?_,?_⟩ |
| · dsimp only [first]; rw [p.cancel b z _ h.2.1,p.opposite _ _ h.1] |
| · unfold second; refine Prod.ext rfl (Prod.ext ?_ rfl) |
| apply p.equals (hs ..) h.2.1 |
| dsimp only; simp_rw [p.cast_shove]; cases b <;> simp <;> ring |
| · unfold pointR; exact Prod.ext (p.opposite (!b) x h.1) rfl |
| · unfold pointZ; exact Prod.ext rfl (Prod.ext (p.cancel b _ _ h.2.1) rfl) |
|
|
| def fair (x y:ℕ)(v:Pane):Pane:=p.pointZ true y (p.pointR true x (p.second true y (p.first true x v))) |
| def dark (x y:ℕ)(v:Pane):Pane:=p.first false x (p.second false y (p.pointR false x (p.pointZ false y v))) |
| lemma sepia (x y) {v} (h:p.proper v): p.proper (p.fair x y v):= |
| (p.stay true y ((p.stay true x ((p.stay true y ((p.stay true x h).1)).2.1)).2.2.1)).2.2.2 |
| lemma back (x y) {v}(h:p.proper v): p.dark x y (p.fair x y v)=v := by |
| let a:=p.first true x v |
| let b:=p.second true y a |
| let c:=p.pointR true x b |
| have h1:p.proper a:=(p.stay true x h).1 |
| have h2:p.proper b:=(p.stay true y h1).2.1 |
| have h3:p.proper c:=(p.stay true x h2).2.2.1 |
| have e1:p.pointZ false y (p.pointZ true y c)=c:=(p.negone true y h3).2.2.2 |
| have e2:p.pointR false x c=b:=(p.negone true x h2).2.2.1 |
| have e3:p.second false y b=a:=(p.negone true y h1).2.1 |
| unfold dark; change p.first false x (p.second false y (p.pointR false x (p.pointZ false y (p.pointZ true y c))))=v |
| rw [e1,e2,e3]; exact (p.negone true x h).1 |
|
|
| def moat (a b i:ℕ):=dig p.n a i-dig p.n b i+(dig p.n b i-dig p.n a i) |
| def hugs (a b: ℕ):=∑ i∈range p.L,(p.moat a b i)^2 |
|
|
| lemma bows (x y) : p.hugs x y+2*p.hinge x y=p.hinge x x+p.hinge y y := by |
| unfold hugs hinge; rw [mul_sum,← sum_add_distrib,← sum_add_distrib] |
| apply sum_congr rfl; intro i _ |
| let a:=dig p.n x i; let b:=dig p.n y i |
| rcases le_total a b with h|h |
| · have he:p.moat x y i+a=b:=by unfold moat; change (a-b+(b-a))+a=b; omega |
| change _^2+2*(a*b)=a*a+b*b; nlinarith |
| have he:p.moat x y i+b=a:=by unfold moat; change (a-b+(b-a))+b=a; omega |
| change _^2+2*(a*b)=a*a+b*b; nlinarith |
| lemma small (x y): p.hugs x y < p.M:=by |
| have hu:= p.n2 |
| have he: p.hugs x y≤ ∑ _∈range p.L,p.n^2:= sum_le_sum fun i _=> by |
| have hh (x i):dig p.n x i< p.n := Nat.mod_lt _ (by omega) |
| apply Nat.pow_le_pow_left |
| unfold moat; have := hh x i; have := hh y i; omega |
| simp at he |
| have hr:=p.L_le |
| unfold M |
| exact lt_of_le_of_lt he (by nlinarith [Nat.mul_le_mul_right (p.n^2) hr]) |
| lemma paw (x y) (hx:x≤p.peak)(hy:y≤p.peak): p.hugs x y=0 ↔ x=y:=by |
| constructor |
| · intro h |
| have he:= p.coded hx |
| apply equal p.n2 he (p.coded hy) |
| intro i hi |
| have hz : (p.moat x y i)^2 ≤ p.hugs x y := single_le_sum |
| (f:=fun i=> (p.moat x y i)^2) (fun _ _=>Nat.zero_le _) (mem_range.2 hi) |
| have hu : p.moat x y i=0:=by rw [h,Nat.le_zero] at hz; simpa using hz |
| unfold moat at hu; omega |
| rintro rfl; simp [hugs,moat] |
|
|
| lemma pupils (x y) {v}(h:p.proper v): |
| p.fair x y v = (v.1, shove p.M true v.2.1 (p.hugs x y),v.2.2) := by |
| have he:=p.opposite true x h.1 |
| apply Prod.ext |
| · exact he |
| refine Prod.ext ?_ rfl |
| have hM:=p.M4 |
| apply p.equals (p.sepia x y h).2.1 (enoughS true (by omega)) |
| unfold fair pointZ second pointR first |
| dsimp only |
| change mix ..=_ at he |
| simp only [show (!(true:Bool))=false from rfl] at he |
| simp only [Bool.not_true, he] |
| simp_rw [p.cast_shove] |
| push_cast |
| rw [p.twist] |
| have ht:= congrArg (fun k:ℕ=>(k:ZMod p.M)) (p.bows x y) |
| push_cast at ht |
| apply add_right_cancel (b:=2*(p.hinge x y:ZMod p.M)) |
| linear_combination -ht |
|
|
| lemma test_eye (x y)(hx:x≤p.peak)(hy:y≤p.peak){v}(h:p.proper v): |
| (p.fair x y v).2.1=v.2.1 ↔ x=y:=by |
| rw [p.pupils x y h] |
| have hM:=p.M4 |
| constructor |
| · intro he |
| have hs:= congrArg (fun k:ℕ=>(k:ZMod p.M)) he |
| rw [p.cast_shove] at hs |
| apply (p.paw x y hx hy).1 |
| apply p.equals (p.small ..) (by omega) |
| simpa using hs |
| intro he; rw [(p.paw x y hx hy).2 he] |
| simp only [shove,ite_true,Nat.add_zero,Nat.mod_eq_of_lt h.2.1] |
| end Rod |
| end ExactDerandomization.Glass |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Glass |
| open Relay Counter NatD Finset |
| namespace Rod |
| variable (p:Rod) |
|
|
| def line (u i:ℕ):Bool:= decide (dig 2 u i=1) |
| def foil (u i:ℕ)(j:ℕ):ℕ:= if j=i then 1- dig 2 u j else dig 2 u j |
| lemma foil_lt (u i j):foil u i j<2:=by |
| unfold foil; have hx:dig 2 u j<2:=Nat.mod_lt _ (by omega); split <;> omega |
| def frosting (u i:ℕ):ℕ:= record 2 (foil u i) p.n |
| lemma freeze (u i): p.frosting u i < p.Q:=under (fun _ _=>foil_lt ..) |
| lemma hit (u i j)(h:j<p.n): dig 2 (p.frosting u i) j = foil u i j:= by |
| unfold frosting; apply letter (by omega) (fun j _=>foil_lt ..) h |
| lemma frost_eq (u i j)(h:j<p.n): |
| line (p.frosting u i) j = if i=j then !(line u j) else line u j:= by |
| by_cases he:i=j |
| · have hz:dig 2 u j<2:=Nat.mod_lt _ (by omega) |
| subst i; have he:(dig 2 u j)=0∨ dig 2 u j=1:=by omega |
| cases he <;> simp_all [line,p.hit u j j h,foil] |
| simp [line,p.hit u i j h,foil,he,Ne.symm he] |
| lemma frost_c {u}(i:ℕ)(h:u < p.Q): |
| p.frosting (p.frosting u i) i=u:=by |
| apply equal (by omega:2 ≤2) (p.freeze ..) h |
| intro j hk; rw [p.hit _ _ _ hk] |
| unfold foil; rw [p.hit _ _ _ hk]; unfold foil |
| split |
| · have hx:dig 2 u j<2:=Nat.mod_lt _ (by omega); omega |
| all_goals simp_all |
|
|
| def glaze (v:Pane)(j:ℕ):Pane:= |
| (v.1,v.2.1,p.frosting v.2.2 (dig p.n v.2.1 j)) |
| def ask (v:Pane)(j:ℕ):Bool:=line v.2.2 (dig p.n v.2.1 j) |
| lemma glaze2 (j:ℕ) {v}(h:p.proper v):p.proper (p.glaze v j) ∧ p.glaze (p.glaze v j) j=v := |
| ⟨⟨h.1,h.2.1,p.freeze ..⟩, Prod.ext rfl (Prod.ext rfl (p.frost_c _ h.2.2))⟩ |
| lemma glass {v}(h:p.proper v)(i x y:ℕ): |
| (p.ask (p.fair x y (p.glaze v i)) i ≠ p.ask (p.fair x y v) i)↔ |
| (dig p.n (p.fair x y v).2.1 i = dig p.n v.2.1 i):=by |
| rw [p.pupils x y h,p.pupils x y (p.glaze2 i h).1] |
| have hk (v i): dig p.n v i < p.n:= Nat.mod_lt _ (by have := p.n2; omega) |
| dsimp only [ask,glaze]; rw [p.frost_eq _ _ _ (hk ..)] |
| split <;> grind |
|
|
| lemma learned (x y)(hx:x≤p.peak)(hy:y≤p.peak){v}(hv:p.proper v): |
| x=y ↔ ∀ i<4, p.ask (p.fair x y (p.glaze v i)) i ≠ p.ask (p.fair x y v) i:=by |
| have hh(i): p.ask (p.fair x y (p.glaze v i)) i ≠ p.ask (p.fair x y v) i↔ |
| dig p.n (p.fair x y v).2.1 i = dig p.n v.2.1 i:=p.glass hv i x y |
| simp_rw [hh,← p.test_eye x y hx hy hv] |
| constructor |
| · intro h i he; rw [h] |
| exact equal p.n2 (p.sepia x y hv).2.1 hv.2.1 |
|
|
| end Rod |
| end ExactDerandomization.Glass |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Glass |
| open Relay Counter Finset NatD |
| namespace Rod |
|
|
| variable {α} [Wire α] {p v u t:PT α ℕ} |
| private abbrev toR (p:PT α ℕ ) (x:Word ) (a:α):Rod:=⟨p x a⟩ |
| lemma nFun (h:Kn p):Kn (fun x a=> (toR p x a).n):=Kn.caplenK.comp (Kn.bl h) |
| lemma lFun (h:Kn p):Kn (fun x a=> (toR p x a).L) := by |
| have hp := h.bl; exact (hp.div hp.bl).succ |
| lemma mFun (h:Kn p):Kn (fun x a=>(toR p x a).M):=Kn.power 4 (nFun h) |
| lemma fFun (h:Kn p):Kn (fun x a=>(toR p x a).F):=by |
| convert (Kn.cap (Kn.power 12 (Kn.caplenK.comp h)) (mFun h) (lFun h)) using 1 |
| ext x a; exact (min_eq_right (Rod.costs _)).symm |
| lemma qFun (h:Kn p):Kn (fun x a=>(toR p x a).Q):=by |
| convert (Kn.cap (Kn.power 2 (Kn.caplenK.comp h)) (Kn.fix 2) (nFun h)) using 1 |
| ext x a; exact (min_eq_right (Rod.costs2 _)).symm |
|
|
| lemma shoveK (b:Bool) {f:PT α ℕ}(hf:Kn f ) (h:Kn v ) (e:Kn u): |
| Kn (fun x a=> shove (f x a) b (v x a) (u x a)):= by |
| cases b |
| · exact ((h.add hf).sub (e.mod hf)).mod hf |
| · exact (h.add e).mod hf |
| lemma drew {f k g:PT α ℕ}(r:PT (α×ℕ) ℕ) (hr:Kn r ) (hf:Kn f ) (hk:Kn k ) (hg:Kn g) |
| (hz : ∀ x a, g x a=(f x a)^(k x a)) (hs:∀ x a,2≤ f x a) |
| (hh:∀ x a j,r x (a,j) < f x a): |
| Kn (fun x a=> record (f x a) (fun j=> r x (a,j)) (k x a)):=by |
| let A:PT (α×ℕ×ℕ) ℕ:= fun x i=> i.2.2+r x (i.1,i.2.1)*min (g x i.1 ) ((f x i.1)^(i.2.1)) |
| have he(x a j ) (hi:j≤k x a): |
| record (f x a) (fun j=>r x (a,j)) j= forNat (fun k v=>A x (a,k,v)) 0 j:=by |
| induction j with |
| | zero=> rfl |
| | succ j ih=> |
| rw [next,ih (by omega), forNat] |
| dsimp only [A]; rw [hz,min_eq_right (Nat.pow_le_pow_right (by have:=hs x a; omega) (by omega))] |
| have hu:=Kn.stroll A _ _ g |
| (Kn.next.right.add ((hr.comp (Kn.first.tuple Kn.next.left)).times |
| (Kn.cap (hg.comp Kn.first) (hf.comp Kn.first) Kn.next.left))) |
| hk (Kn.fix 0) hg (by |
| intro x a j hi; rw [← he x a j hi,hz] |
| exact (under (fun k h=> hh x a k)).le.trans (Nat.pow_le_pow_right (by have:=hs x a; omega) hi)) |
| convert hu using 1 |
| ext x a |
| exact he x a _ le_rfl |
|
|
| lemma mixK (b:Bool ) (h:Kn p ) (e:Kn v ) (f:Kn u):Kn (fun x a=> (toR p x a).mix b (v x a ) (u x a)):=by |
| let m:PT α ℕ:=fun x a=>(toR p x a).M |
| have hs:Kn m:=mFun h |
| refine drew (fun x (w:α×ℕ)=> let a:=w.1; shove (m x a) b (dig (m x a) (v x a) w.2) (dig (toR p x a).n (u x a) w.2)) |
| ?_ hs (lFun h) (fFun h) (fun _ _=>rfl) (fun x a=>(Nat.le_trans (by omega) (M4 (toR p x a)))) |
| (fun x a j=>enoughS _ (lt_of_lt_of_le (by omega) (M4 (toR p x a)))) |
| exact shoveK b (hs.comp Kn.first) |
| (digK (hs.comp Kn.first) (e.comp Kn.first) Kn.next) |
| (digK ((nFun h).comp Kn.first) (f.comp Kn.first) Kn.next) |
| lemma glazeK {a:PT α Pane}(h:Kn p ) (e:Kn a ) (f:Kn u): Kn (fun x i=> (toR p x i).glaze (a x i ) (u x i)):=by |
| have hf:=e.right.left; have he:= e.right.right |
| let r (x i):=dig (toR p x i).n ((a x i).2.1) (u x i) |
| have hr:Kn r:=digK (nFun h) hf f |
| apply Kn.tuple e.left |
| apply hf.tuple |
| refine drew (fun x (w:α×ℕ)=> foil (a x w.1).2.2 (r x w.1) w.2) |
| ?_ (Kn.fix 2) (nFun h) (qFun h) (fun _ _=>rfl) |
| (fun _ _=>by omega) (fun x i j=>foil_lt ..) |
| have hz := digK (Kn.fix 2) (he.comp Kn.first) Kn.next |
| exact Kn.next.cond_eq (hr.comp Kn.first) ((Kn.fix _).sub hz) hz |
| lemma askK {a:PT α Pane}(h:Kn p ) (e:Kn a ) (f:Kn u): Kn (fun x i=> (toR p x i).ask (a x i ) (u x i)) := |
| (digK (Kn.fix 2) e.right.right (digK (nFun h) e.right.left f)).eq (Kn.fix 1) |
|
|
| lemma sumFun {n t:PT α ℕ} (hn:Kn n ) (hr:Kn t ) (f:PT (α×ℕ) ℕ ) (hf:Kn f) |
| (hz:∀ x a j, f x (a,j)≤ t x a) : |
| Kn (fun x a=> ∑ j∈range (n x a), f x (a,j)):=by |
| let g:PT (α×ℕ×ℕ) ℕ:=fun x a=>a.2.2+ f x (a.1,a.2.1) |
| have hs(x a j) : forNat (fun i v=>g x (a,i,v)) 0 j=∑ i∈range j,f x (a,i):=by |
| induction j <;> simp_all only [forNat,sum_range_succ,g] ; simp |
| simpa only [hs] using Kn.stroll g n (fun _ _=>0) (fun x a=> n x a*t x a) |
| (Kn.next.right.add (hf.comp (Kn.first.tuple Kn.next.left))) hn (Kn.fix 0) (hn.times hr) (by |
| intro x a i hi |
| rw [hs] |
| have he: ∑ j∈range i,f x (a,j)≤ ∑ _∈range i,t x a:=sum_le_sum fun j _=> hz x a j |
| apply he.trans |
| simpa using Nat.mul_le_mul_right (t x a) hi) |
| lemma shadeSumK {f g: PT α ℕ}(hf:Kn f ) (hg:Kn g) |
| (he:∀ x a,1≤f x a∧1≤g x a ) (h:Kn p ) (hz:Kn v ) (hm:Kn u): |
| Kn (fun x a=>∑ i∈range ((toR p x a).L), |
| dig (f x a) (v x a) i * dig (g x a) (u x a) i):= |
| sumFun (lFun h) (hf.times hg) _ |
| ((digK (hf.comp Kn.first ) (hz.comp Kn.first) Kn.next).times |
| (digK (hg.comp Kn.first ) (hm.comp Kn.first) Kn.next)) |
| (fun x a _=> Nat.mul_le_mul (Nat.mod_lt _ (he x a).1).le (Nat.mod_lt _ (he x a).2).le) |
| lemma hingeK (h:Kn p ) (hz:Kn v ) (hm:Kn u): Kn (fun x a=> (toR p x a).hinge (v x a ) (u x a)) := |
| shadeSumK (nFun h) (nFun h) (fun x a=>by have:= n2 (toR p x a); exact ⟨by omega,by omega⟩) h hz hm |
| lemma aloK (h:Kn p ) (hz:Kn v ) (hm:Kn u): Kn (fun x a=> (toR p x a).aloft (v x a ) (u x a)) := |
| shadeSumK (mFun h) (nFun h) |
| (fun x a=>⟨Nat.le_trans (by omega) (M4 _), Nat.le_trans (by omega) (n2 _)⟩) h hz hm |
| lemma firstK (b:Bool ) (h:Kn p) (hs:Kn v) {g:PT α Pane} (he:Kn g): |
| Kn (fun x a=> (toR p x a).first b (v x a) (g x a)) := |
| (mixK b h he.left hs).tuple ((shoveK b (mFun h) he.right.left (hingeK h hs hs)).tuple he.right.right) |
| lemma upzK (b:Bool ) (h:Kn p) (hs:Kn v) {g:PT α Pane} (he:Kn g): |
| Kn (fun x a=> (toR p x a).pointZ b (v x a) (g x a)) := |
| he.left.tuple ((shoveK b (mFun h) he.right.left ((Kn.fix 2).times (aloK h he.left hs))).tuple |
| he.right.right) |
| lemma svK (b:Bool ) (h:Kn p) (hs:Kn v) {g:PT α Pane} (he:Kn g): |
| Kn (fun x a=> (toR p x a).pointR b (v x a) (g x a)) := |
| (mixK (!b) h he.left hs).tuple he.right |
| lemma secondK (b:Bool ) (h:Kn p) (hs:Kn v) {g:PT α Pane} (he:Kn g): |
| Kn (fun x a=> (toR p x a).second b (v x a) (g x a)) := |
| he.left.tuple ((shoveK (!b) (mFun h) (shoveK b (mFun h) he.right.left (hingeK h hs hs)) |
| ((Kn.fix 2).times (aloK h he.left hs))).tuple he.right.right) |
|
|
| end Rod |
| end ExactDerandomization.Glass |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Glass |
| open Relay Counter NatD Rod |
|
|
| abbrev Foot:=ℕ×Pane |
|
|
| inductive Mode where |
| | push | step2 | ret | dial |
| deriving DecidableEq |
| def pivot: Mode→Bool |
| | .push| .ret=>true |
| | _=>false |
| def pigment (p:Rod) : Mode→ Bool→ℕ→Pane→Pane |
| | .push=>p.first |
| | .step2=>p.second |
| | .ret=>p.pointR |
| | .dial=>p.pointZ |
|
|
| structure Eye where |
| peak:Cub ℕ ℕ |
| visit : Mode→Bool → Cog |
|
|
| namespace Eye |
| variable (p:Eye) |
| def eye (_:Word)(a:Plot):Foot:= dec a.2.2 |
| def peg (x:Word)(a:Plot):Rod:=⟨p.peak.f x a.1⟩ |
| def flip (k:ℕ)(x:Word)(a:Plot):Site := |
| let u:=eye x a |
| (0,enc ((u.1,(p.peg x a).glaze u.2 k):Foot)) |
| lemma flipK (k):Kn (p.flip k):=by |
| have he:= p.peak.runs.comp (Kn.first (β:=Site)) |
| have hc:= (Kn.unpack (α:=Foot)).comp (Kn.next (α:=ℕ) (β:=Site)).right |
| exact (Kn.fix _).tuple (Kn.wash.comp (hc.left.tuple (glazeK he hc.right (Kn.fix _)))) |
| def glare (k:ℕ)(x:Word)(a:Plot):Bool:= (p.peg x a).ask (eye x a).2 k |
| lemma glareK (k):Kn (p.glare k):= |
| askK (p.peak.runs.comp Kn.first) ((Kn.unpack (α:=Foot)).comp Kn.next.right).right (Kn.fix _) |
| def fairp (p:Eye)(c:Cog):Cog := |
| .seq (p.visit .push true) (.seq (p.visit .step2 true) (.seq (p.visit .ret true) |
| (.seq (p.visit .dial true) c))) |
| def fairm (p:Eye)(c:Cog):Cog := |
| .seq (p.visit .dial false) (.seq (p.visit .ret false) (.seq (p.visit .step2 false) |
| (.seq (p.visit .push false) c))) |
| def Glare (p:Eye)(k:ℕ):Flag:=⟨_,p.glareK k⟩ |
| def Toggle (p:Eye)(k:ℕ):Cog:= .edit ⟨_,p.flipK k⟩ |
| def after (p:Eye)(k:ℕ)(b:Bool)(yes no: Cog):Cog:= |
| .seq (.edit ⟨_,Kn.next⟩) |
| (p.fairm (.seq (p.Toggle k) (p.fairp (.bif (p.Glare k) |
| (p.fairm (if b then no else yes)) |
| (p.fairm (if b then yes else no)))))) |
| def block (p:Eye) (k:ℕ)(yes no:Cog):Cog:= |
| .seq (p.Toggle k) (p.fairp (.bif (p.Glare k) (p.after k true yes no) (p.after k false yes no))) |
| def nexts (p:Eye) : ℕ→ Cog→ Cog→ Cog |
| | 0,y,_=>y |
| | k+1,y,n=>p.block k (p.nexts k y n) n |
|
|
| structure Mantle where |
| l : Lot |
| q :ℕ |
| v :Level |
| k:ℕ |
| d:ℕ |
| id:ℕ |
| namespace Mantle |
| variable (m:Mantle) |
| abbrev param:Rod:=⟨p.peak.f m.l.x m.q⟩ |
| abbrev knot (v:Pane):Site:=(0,enc ((m.id,v):Foot)) |
| abbrev wants : Cog→Site→Site→ Prop:= Lot.Mane m.l m.k m.v m.d m.q |
| end Mantle |
|
|
| structure Twirl (p:Eye)(m:Mantle)(x y:ℕ):Prop where |
| walk : ∀ v,(Mantle.param p m).proper v → ∀ M b, |
| m.wants (p.visit M b) (m.knot v) (m.knot |
| (pigment (Mantle.param p m) M b (if pivot M then x else y) v)) |
|
|
| namespace Twirl |
| variable {p m x y} (h:p.Twirl m x y) |
| include h |
| private abbrev rod (p:Eye)(m:Mantle):Rod:=Mantle.param p m |
| lemma idol (v)(hv:(rod p m).proper v):m.l.state m.k m.v (m.knot v):= (h.walk v hv .push true).spots.1 |
| lemma tint {v}(k)(hv:(rod p m).proper v): |
| m.wants (p.Toggle k) (m.knot v) (m.knot ((rod p m).glaze v k)):= |
| .edit (by simp [flip,eye,Mantle.knot]; rfl) |
| (h.idol v hv) (h.idol _ ((rod p m).glaze2 k hv).1) |
| omit h in |
| lemma looked (v k): (p.Glare k).f m.l.x (m.q,m.knot v)=(rod p m).ask v k:=by |
| simp [Glare,glare,eye,Mantle.knot]; rfl |
| lemma furl {v}(hv:(rod p m).proper v){c u} |
| (hc:m.wants c (m.knot ((rod p m).fair x y v)) u): |
| m.wants (p.fairp c) (m.knot v) u:=by |
| let r:=rod p m |
| let f:=r.first true x v; let g:=r.second true y f |
| have he1:r.proper f:=(r.stay true x hv).1 |
| have he2:r.proper g:=(r.stay true y he1).2.1 |
| exact .seq (h.walk v hv .push true) (.seq (h.walk _ he1 .step2 true) |
| (.seq (h.walk _ he2 .ret true) (.seq (h.walk _ (r.stay true x he2).2.2.1 .dial true) hc))) |
| lemma moot {v}(hv:(rod p m).proper v){c u}(hc:m.wants c (m.knot v) u): |
| m.wants (p.fairm c) (m.knot ((rod p m).fair x y v)) u:=by |
| let r:=rod p m |
| let w:=r.fair x y v |
| let f:=r.pointZ false y w |
| let g:=r.pointR false x f |
| have h0:r.proper w:=r.sepia x y hv |
| have h1:r.proper f:=(r.stay false y h0).2.2.2 |
| have h2:r.proper g:=(r.stay false x h1).2.2.1 |
| have ht:m.wants c (m.knot (r.dark x y w)) u:= by rwa [r.back x y hv] |
| exact .seq (h.walk w h0 .dial false) (.seq (h.walk _ h1 .ret false) |
| (.seq (h.walk _ h2 .step2 false) (.seq (h.walk _ (r.stay false y h2).2.1 .push false) ht))) |
|
|
| lemma retina {v} (hv:(rod p m).proper v)(k){b y1 n c} |
| (_:(rod p m).ask ((rod p m).fair x y ((rod p m).glaze v k)) k=b) |
| (h1:b≠ (rod p m).ask ((rod p m).fair x y v) k → m.wants y1 (m.knot v) c) |
| (h0:b= (rod p m).ask ((rod p m).fair x y v) k → m.wants n (m.knot v) c): |
| m.wants (p.after k b y1 n) (m.knot ((rod p m).fair x y ((rod p m).glaze v k))) c:=by |
| let r:=rod p m |
| have hp:=(rod p m).glaze2 k hv |
| have heo:=h.idol _ (r.sepia x y hp.1) |
| have hz:=h.tint k hp.1 |
| rw [hp.2] at hz |
| refine .seq (.edit rfl heo heo) (h.moot hp.1 (.seq hz (h.furl hv ?_))) |
| cases he0:r.ask (r.fair x y v) k |
| · apply Lot.Mane.no ((looked (p := p) (m := m) (r.fair x y v) k).trans he0) |
| apply h.moot hv |
| split |
| · next e=> apply h1; change b≠r.ask (r.fair x y v) k; grind |
| · next e=> apply h0; change b=r.ask (r.fair x y v) k; grind |
| apply Lot.Mane.yes ((looked (p := p) (m := m) (r.fair x y v) k).trans he0) |
| apply h.moot hv |
| split |
| · next e=> apply h0; change b=r.ask (r.fair x y v) k; grind |
| · next e=> apply h1; change b≠r.ask (r.fair x y v) k; grind |
|
|
| abbrev condH (r:Rod)(x y i:ℕ)(v:Pane):Prop:= |
| r.ask (r.fair x y (r.glaze v i)) i≠r.ask (r.fair x y v) i |
| lemma rosette {v} (hv:(rod p m).proper v)(k){y1 n c} |
| (hp:condH (rod p m) x y k v → m.wants y1 (m.knot v) c) |
| (he:¬condH (rod p m) x y k v → m.wants n (m.knot v) c): |
| m.wants (p.block k y1 n) (m.knot v) c:=by |
| apply Lot.Mane.seq (h.tint k hv) |
| apply h.furl ((rod p m).glaze2 k hv).1 |
| let r:=rod p m |
| let z:=r.fair x y (r.glaze v k) |
| have hm(b:Bool)(hb:r.ask z k=b): m.wants (p.after k b y1 n) (m.knot z) c := by |
| apply h.retina hv k hb |
| · intro hs; rw [←hb] at hs; exact hp hs |
| intro hs |
| apply he; intro hf |
| change r.ask z k≠_ at hf |
| exact hf (hb.trans hs) |
| cases e : r.ask z k |
| · exact .no (((looked (p := p) (m := m)) z k).trans e) (hm _ e) |
| · exact .yes (((looked (p := p) (m := m)) z k).trans e) (hm _ e) |
| lemma blocks {v} (hv:(rod p m).proper v)(k){y1 n c} |
| (hp:(∀ i<k,condH (rod p m) x y i v) → m.wants y1 (m.knot v) c) |
| (he:(∃ i<k,¬condH (rod p m) x y i v) → m.wants n (m.knot v) c): |
| m.wants (p.nexts k y1 n) (m.knot v) c:=by |
| induction k with |
| | zero=> exact hp (by omega) |
| | succ k ih=> |
| apply h.rosette hv k |
| · intro hb |
| refine ih (fun e=>hp ?_) ?_ |
| · intro i hi; rcases eq_or_lt_of_le (Nat.le_of_lt_succ hi) with hs|hg |
| · rw [hs]; exact hb |
| exact e _ hg |
| · rintro ⟨i,hi,e⟩; exact he ⟨i,by omega,e⟩ |
| intro hb; exact he ⟨k,by omega,hb⟩ |
| theorem done0 {v}(hv:(Mantle.param p m).proper v){y1 n c} |
| (hx:x≤(Mantle.param p m).peak)(hy:y≤(Mantle.param p m).peak) |
| (hp:x=y → m.wants y1 (m.knot v) c)(he:x≠y → m.wants n (m.knot v) c): |
| m.wants (p.nexts 4 y1 n) (m.knot v) c:=by |
| have hs := (rod p m).learned x y hx hy hv |
| apply h.blocks hv 4 (fun hh=>hp (hs.2 hh)) |
| rintro ⟨i,hi,hv⟩ |
| exact he fun h=> hv (hs.1 h i hi) |
|
|
| end Twirl |
| end Eye |
| end ExactDerandomization.Glass |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Glass |
| open Relay Counter |
|
|
| /-- A visit whose (single) optional subterminal path is delegated. |
| The hop tokens forward/back are determined by the selector's code, |
| which belongs to a short range. Its pure action compiled at leaves |
| can incorporate post label maps. -/ |
| structure Vase where |
| ask:Cub ℕ ℕ |
| probe:Bool→ Cub Slip ℕ |
| dives:Cub Slip Bool |
| bud:Cub Slip ℕ |
| next:Cub Plot Site |
|
|
| namespace Vase |
| variable (v:Vase) |
| def start :Cog:=.toss ⟨fun x a=>v.ask.f x a.1,v.ask.runs.comp Kn.first⟩ |
| ⟨_,Kn.next⟩ |
| def fork :Flag:=⟨fun x a=>v.dives.f x (a.1,a.2.1),v.dives.runs.comp (Kn.first.tuple Kn.next.left)⟩ |
| def ahead : Cog := .toss (v.probe true) |
| ⟨fun _ a=>(a.1.2,a.2.2), Kn.first.right.tuple Kn.next.right⟩ |
| abbrev Belt:=ℕ×ℕ |
| def budfeed (_:Word) (a:Drain):Site := (enc ((a.1.2,a.2.1):Belt),a.2.2) |
| lemma budK:Kn budfeed:=(Kn.wash.comp (Kn.first.right.tuple Kn.next.left)).tuple Kn.next.right |
| def seed (x:Word ) (a:Plot):Site:= |
| budfeed x ((a.1,a.2.1),v.next.f x a) |
| lemma seedK:Kn v.seed:=budK.comp ((Kn.first.tuple Kn.next.left).tuple v.next.runs) |
| def lance: Cog:= .bif v.fork (.toss v.bud ⟨_,budK⟩) (.edit ⟨_,v.seedK⟩) |
| def headQ (x:Word ) (a:Slip):ℕ:=(v.probe false).f x (a.1,(dec a.2:Belt).1) |
| def lastQ (_:Word ) (a:Drain):Site:= ((dec a.1.2:Belt).2,a.2.2) |
| lemma headK:Kn v.headQ:= (v.probe false).runs.comp |
| (Kn.first.tuple ((Kn.unpack (α:=Belt)).comp Kn.next).left) |
| lemma lastK:Kn lastQ := (((Kn.unpack (α:=Belt)).comp Kn.first.right).right).tuple Kn.next.right |
| def dawn: Cog:=.seq v.ahead (.seq v.lance (.toss ⟨_,v.headK⟩ ⟨_,lastK⟩)) |
| def cold0:Cub Plot Bool:=⟨fun _ a=> decide (a.2.1=0), Kn.next.left.eq (Kn.fix 0)⟩ |
| def play:Cog:=.seq v.start (.bif cold0 (.edit ⟨_,Kn.next⟩) v.dawn) |
|
|
| structure Den where |
| l:Lot |
| w:ℕ |
| d:ℕ |
| q:ℕ |
| k:ℕ |
| namespace Den |
| variable (a:Den) |
| abbrev charge:=10*a.k |
| def good:= 4 ≤ a.k∧1 ≤ a.d∧ a.d ≤ a.w |
| def pull (q:ℕ):= (a.l.book q).w + a.d ≤ a.w ∧ (a.l.book q).t=0 |
| abbrev rootD(a:Den):Level:=⟨a.w,0⟩ |
| abbrev meets:=Lot.Mane a.l a.charge a.rootD a.d a.q |
| def bit (z:ℕ):=lb z ≤ a.k*a.d |
| abbrev atCall (q h:ℕ ) (u:Site) := Boots a.l.x a.l.F a.l.P q a.l.P (0,h) u |
| lemma affordable {h}(hk:a.good ) (ht:lb h ≤ 6*a.k*a.d) |
| (i ) (e:i ≤ a.l.F.limit):a.l.state a.charge a.rootD (h,i):=by |
| obtain ⟨p,g,f⟩:=hk |
| refine ⟨e,?_⟩; unfold span; dsimp only [rootD,charge] |
| nlinarith [Nat.mul_le_mul_left a.k f, show 6*a.k ≤10*a.k by omega, |
| Nat.mul_le_mul_left (10*a.k*(10*a.k)) f] |
| lemma fit {q z}(hk:a.good ) (ht:lb z ≤ 6*a.k*a.d ) (h:a.pull q): |
| a.l.jump a.charge a.rootD a.d z q:=by |
| obtain ⟨h1,h2,h3⟩:=hk; obtain ⟨ha,hb⟩:=h |
| refine ⟨ha,?_⟩; change span _ (a.w-_) 0 _ _ |
| rw [hb]; unfold span; dsimp only [charge] |
| have hw:a.d ≤ a.w-(a.l.book q).w:=by omega |
| nlinarith [Nat.mul_le_mul_left (10*a.k*(10*a.k)) hw] |
| lemma sizeQ {x}(_:a.good ) (ht:a.bit x):lb x ≤ 6*a.k*a.d:=by unfold bit at ht; nlinarith |
| lemma bsize {x y:ℕ}(h:a.good ) (ht:a.bit x ) (hz:a.bit y):lb (enc ((x,y):Belt)) ≤ 6*a.k*a.d:=by |
| have he : lb (enc (x,y))≤2*lb x+lb y+2:=measure_pair _ _ |
| unfold bit at *; obtain ⟨hx,hv,ht'⟩:=h |
| nlinarith |
| lemma bit0 (h:a.good): a.bit 0:= by unfold bit; rw [lb_zero]; obtain ⟨hv,hx,hc⟩:=h; nlinarith |
| end Den |
|
|
| lemma perform {s:Den} (h:s.good ) (x h0:ℕ) (hc:s.bit h0) |
| (he:s.pull (v.ask.f s.l.x s.q)) |
| (hy:s.atCall (v.ask.f s.l.x s.q) x (h0,x)): |
| s.meets v.start (0,x) (h0,x):= |
| let ht:=hy.fits.2.2.1 |
| .toss rfl rfl (s.affordable h (s.sizeQ h (s.bit0 h)) _ ht) |
| (s.affordable h (s.sizeQ h hc) _ ht) (s.fit h (s.sizeQ h (s.bit0 h)) he) hy |
|
|
| lemma arrives {s:Den} (h:s.good){x y h0 w z i:ℕ} (ht:s.bit h0 ) (hb:s.bit i) |
| (hs:s.meets v.start (0,x ) (h0,x) ) (he:h0 ≠0) |
| (hf:∀ b,s.pull ((v.probe b).f s.l.x (s.q,h0))) |
| (hp:s.atCall ((v.probe true).f s.l.x (s.q,h0)) x (1,y)) |
| (hg:s.atCall ((v.probe false).f s.l.x (s.q,h0)) z (1,w)) |
| (hE:v.dives.f s.l.x (s.q,h0)=true → |
| s.pull (v.bud.f s.l.x (s.q,h0)) ∧ s.atCall (v.bud.f s.l.x (s.q,h0)) y (i,z)) |
| (hD:v.dives.f s.l.x (s.q,h0)=false → v.next.f s.l.x (s.q,h0,y)=(i,z)): |
| s.meets v.play (0,x) (i,w):=by |
| have hx:=s.sizeQ h ht; have hi:=s.bsize h ht hb |
| have hu:=s.affordable h hx y hp.fits.2.2.1 |
| have hA:=s.affordable h hi z hg.fits.1.2.1 |
| have h1:s.meets v.ahead (h0,x ) (h0,y) := |
| .toss rfl rfl hs.spots.2 hu (s.fit h hx (hf true)) hp |
| have h2: s.meets v.lance (h0,y) (enc (h0,i),z):=by |
| cases he:v.dives.f s.l.x (s.q,h0) |
| · apply Lot.Mane.no he |
| apply Lot.Mane.edit ?_ hu hA |
| change v.seed _ _=_; unfold seed budfeed; dsimp only |
| rw [hD he] |
| · obtain ⟨hf,hp⟩:= hE he |
| exact .yes he (.toss rfl rfl hu hA (s.fit h hx hf) hp) |
| apply Lot.Mane.seq hs |
| apply Lot.Mane.no (show decide (h0=0)=false by simp [he]) |
| refine .seq h1 (.seq h2 (.toss ?_ ?_ hA (s.affordable h (s.sizeQ h hb) _ hg.fits.2.2.1) |
| (s.fit h hi (hf false)) hg)) |
| · change v.headQ ..=_; simp [headQ] |
| · change lastQ s.l.x _=_; simp [lastQ] |
|
|
| lemma failed {s:Den} {x} (hv:s.meets v.start (0,x ) (0,x)): |
| s.meets v.play (0,x ) (0,x):= .seq hv (.yes rfl (.edit rfl hv.spots.2 hv.spots.2)) |
|
|
| end Vase |
| end ExactDerandomization.Glass |
|
|
| end |
|
|
| end OAI |
|
|
