| import OAI.Computability.Logspace.AllocationPrograms |
|
|
| namespace OAI |
|
|
| /-! |
| Canonical contour queries and bounded path selection. |
|
|
| From OpenAI, *Exact Derandomization of Logarithmic Space: L = RL = BPL*. |
| -/ |
|
|
| set_option autoImplicit true |
|
|
| section |
|
|
| namespace ExactDerandomization.Sub |
| open Relay Swirl Mint Counter |
|
|
| / |
| to an endpoint will be assembled with repeated stationary queries from |
| the initiation. use steps=0 for the plain cap kernel. -/ |
| structure Bow where |
| alpha : Cub ℕ ℕ |
| clipA : Cub ℕ ℕ |
| ports : Cub ℕ ℕ |
| steps : Cub ℕ ℕ |
| dress : Cub Bean ℕ |
| scent : Cub Node ℕ |
| padding : Cub ℕ ℕ |
| ask : Cub Node ℕ |
| before : Cub Bean ℕ |
| knot : Cub Bean ℕ |
| other : Cub Bean ℕ |
| passp : Cub Bean ℕ |
| haskid : Cub Bean Bool |
|
|
| abbrev Jet := ℕ×ℕ×ℕ×ℕ×ℕ |
| namespace Jet |
| abbrev band (v:Jet):= v.1 |
| abbrev port (v:Jet):= v.2.1 |
| abbrev rune (v:Jet):=v.2.2.1 |
| abbrev invp (v:Jet):=v.2.2.2.1 |
| abbrev sizeJ (v:Jet):=v.2.2.2.2 |
| def jik (v:Jet) (b h e:ℕ) :Jet:=(b,port v,h,e,sizeJ v) |
| def turn (v:Jet) (b:ℕ):Jet:=jik v b (rune v) (invp v) |
|
|
| def cap (s:ℕ):Jet:= dec (fore s) |
| lemma capK {α} [Wire α] (v:PT α ℕ) (h:Kn v):Kn (fun x a=>cap (v x a)):= |
| Kn.unpack.comp h.top |
| lemma jikK {α} [Wire α] (v:PT α Jet) (b h e:PT α ℕ) (hv:Kn v) (hb:Kn b) (hh:Kn h) (he:Kn e): |
| Kn (fun x a=> jik (v x a) (b x a) (h x a) (e x a)) := |
| hb.tuple (hv.right.left.tuple (hh.tuple (he.tuple hv.right.right.right.right))) |
| lemma turnK {α} [Wire α] (v:PT α Jet) (b:PT α ℕ) (hv:Kn v) (hb:Kn b): |
| Kn (fun x a=>turn (v x a) (b x a)) := |
| jikK _ _ _ _ hv hb hv.right.right.left hv.right.right.right.left |
| def tug (s:ℕ)(v:Jet):ℕ:= cord (enc v) s |
| lemma tugK {α} [Wire α] (s:PT α ℕ) (v:PT α Jet) (hs:Kn s)(hv:Kn v): |
| Kn (fun x a=>tug (s x a) (v x a)) := (Kn.wash.comp hv).push hs |
| @[simp] lemma cap_tug (v:Jet ) (s): cap (tug s v)=v:= by simp [cap,tug] |
| @[simp] lemma aft_tug (v:Jet ) (s): aft (tug s v)=s:= by simp [tug] |
| end Jet |
| abbrev Card := ℕ×ℕ×ℕ×ℕ |
|
|
| def cname (b p i s:ℕ): ℕ := enc ((b,p,i,s):Card) |
| abbrev prime (p) :=cname 0 p 0 0 |
| abbrev tell (p i s):=cname 1 p i s |
| abbrev going (p s):=cname 2 p 0 s |
| abbrev done (p) :=cname 3 p 0 0 |
| lemma cnameK {α} [Wire α] (b p i s:PT α ℕ) (h:Kn b) (hp:Kn p) (hi:Kn i) (hs:Kn s): |
| Kn (fun x a=>cname (b x a ) (p x a ) (i x a ) (s x a)) := |
| Kn.wash.comp (h.tuple (hp.tuple (hi.tuple hs))) |
| @[simp] lemma decname (b p i s):dec (cname b p i s)=((b,p,i,s):Card) := Wire.eq _ |
|
|
| namespace Bow |
| variable (p:Bow) |
|
|
| def readyJ (x:Word) (a:Node):Jet:=(0,a.2,0,0,p.padding.f x a.1) |
| lemma readyK : Kn p.readyJ := |
| (Kn.fix _).tuple (Kn.next.tuple ((Kn.fix _).tuple ((Kn.fix _).tuple (p.padding.runs.comp Kn.first)))) |
|
|
| def hint (α:ℕ)(f:Jet):Bean:=(α,Jet.port f,Jet.rune f) |
|
|
| abbrev Xtra := Node×ℕ×ℕ |
| def along (x:Word) (a:Xtra) := |
| p.other.f x (hint a.2.2 (dec a.2.1)) |
| def journey : PT Node ℕ := |
| sweep p.along (fun x a=> windback x a.2) (fun x a=>p.alpha.f x a.1) |
| (fun x a=>p.clipA.f x a.1) |
| lemma hintK {α} [Wire α] (f:PT α ℕ)(v:PT α Jet)(h:Kn f)(e:Kn v): |
| Kn (fun x a=> hint (f x a) (v x a)):=h.tuple (e.right.left.tuple e.right.right.left) |
| lemma journeyK : Kn p.journey:= Kn.sweepK _ _ _ _ |
| (p.other.runs.comp (hintK _ _ Kn.next.right (Kn.unpack.comp Kn.next.left))) |
| (Kn.windbackK.comp Kn.next) (p.alpha.runs.comp Kn.first) |
| (p.clipA.runs.comp Kn.first) |
|
|
| abbrev Cap := ℕ×ℕ×ℕ |
| abbrev Lift := ℕ×ℕ×ℕ×ℕ |
| abbrev purec (i:ℕ):Cap :=(0,0,i) |
| def inprog (x:Word) (a:Lift) : Cap := |
| let (q,o,s,i):=a |
| let v:=Jet.cap s |
| let t:=aft s |
| let α:=p.journey x (q,t) |
| let H:= hint α v |
| let work := fun z=> going o (Jet.tug t z) + 1 |
| if Jet.band v=0 then (1,p.ask.f x (α,Jet.port v), if i=0 then 0 else work (Jet.jik v 1 i 0)) |
| else if Jet.band v=1 then (2,p.before.f x H,work (Jet.jik v 2 (Jet.rune v) i)) |
| else if Jet.band v=2 then |
| if p.haskid.f x H then |
| purec (going o (Jet.tug (Jet.tug t (Jet.turn v 3)) (p.readyJ x (p.other.f x H,p.passp.f x H)))+1) |
| else purec (work (Jet.turn v 4)) |
| else if Jet.band v=4 then (2,p.knot.f x H,work (Jet.turn v 5)) |
| else if Jet.band v=5 then |
| if t≤1 then purec (done o+1) |
| else purec (going o (Jet.tug (aft t) (Jet.turn (Jet.cap t) 4))+1) |
| else purec 0 |
|
|
| lemma pureK {α} [Wire α] (x:PT α ℕ) (h:Kn x) : Kn (fun w a=>purec (x w a)) := |
| (Kn.fix _).tuple ((Kn.fix _).tuple h) |
| lemma goingK {α} [Wire α] (x y:PT α ℕ)(h:Kn x)(g:Kn y) : |
| Kn (fun w a=> going (x w a ) (y w a)+1) := |
| (cnameK _ _ _ _ (Kn.fix 2) h (Kn.fix 0) g).succ |
|
|
| set_option maxRecDepth 2048 in |
| lemma progK: Kn p.inprog:=by |
| have h:Kn (fun (_:Word) (a:Lift)=>a.1):=Kn.first |
| have e:Kn (fun (_:Word)(a:Lift)=>a.2):=Kn.next |
| let o:PT Lift ℕ:=fun _ a=>a.2.1 |
| let T:PT Lift ℕ:=fun _ a=> aft a.2.2.1 |
| let F:PT Lift Jet:=fun _ a=> Jet.cap a.2.2.1 |
| let A:PT Lift ℕ:=fun x a=> p.journey x (a.1,T x a) |
| have hs:Kn o:=e.left |
| have hw:Kn T:=e.right.left.tail |
| have hf:Kn F:=Jet.capK _ e.right.left |
| have ha:Kn A:=p.journeyK.comp (h.tuple hw) |
| have hp:=hintK A F ha hf |
| let work (z:PT Lift Jet):PT Lift ℕ:=fun x a=>going (o x a) (Jet.tug (T x a) (z x a))+1 |
| have hk (v : PT Lift Jet) (h:Kn v):Kn (work v):=goingK _ _ hs (Jet.tugK _ _ hw h) |
| have hi:=e.right.right |
| have hc:=hf.left |
| let xik (k b:ℕ) (u:PT Lift ℕ) := fun x a=>Jet.jik (F x a) k (u x a) b |
| let w2 : PT Lift Jet:=fun x a=>Jet.jik (F x a) 2 (Jet.rune (F x a)) (a.2.2.2) |
| have hy : Kn w2:=Jet.jikK _ _ _ _ hf (Kn.fix _) hf.right.right.left hi |
| let turn (i:ℕ):PT Lift Jet:= fun x a=>Jet.turn (F x a) i |
| have hx(i):Kn (turn i):=Jet.turnK _ _ hf (Kn.fix _) |
| exact hc.cond_eq (Kn.fix 0) |
| ((Kn.fix _).tuple ((p.ask.runs.comp (ha.tuple hf.right.left)).tuple |
| (hi.cond_eq (Kn.fix 0) (Kn.fix _) (hk (xik 1 0 _) (Jet.jikK _ _ _ _ hf (Kn.fix _) hi (Kn.fix _)))))) |
| (hc.cond_eq (Kn.fix 1) |
| ((Kn.fix _).tuple ((p.before.runs.comp hp).tuple (hk _ hy))) |
| (hc.cond_eq (Kn.fix 2) |
| ((p.haskid.runs.comp hp).cond |
| (pureK _ (goingK _ _ hs (Jet.tugK _ _ (Jet.tugK _ _ hw (hx 3)) |
| (p.readyK.comp ((p.other.runs.comp hp).tuple (p.passp.runs.comp hp)))))) |
| (pureK _ (hk _ (hx 4)))) |
| (hc.cond_eq (Kn.fix 4) |
| ((Kn.fix _).tuple ((p.knot.runs.comp hp).tuple (hk _ (hx 5)))) |
| (hc.cond_eq (Kn.fix 5) |
| (hw.cond_le (Kn.fix 1) |
| (pureK _ ((cnameK _ _ _ _ (Kn.fix 3) hs (Kn.fix 0) (Kn.fix 0)).succ)) |
| (pureK _ (goingK _ _ hs (Jet.tugK _ _ hw.tail |
| (Jet.turnK _ _ (Jet.capK _ hw) (Kn.fix 4)))))) |
| (Kn.fix _))))) |
|
|
| end Bow |
| end ExactDerandomization.Sub |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Sub |
| open Relay Mint Swirl Counter |
| namespace Bow |
| variable (p:Bow) |
|
|
| abbrev Cover:= ℕ×Card×ℕ |
| def air (x:Word)(a:Cover):Cap := |
| let (q,v,h):=a |
| let (b,o,i,w):=v |
| if b=0 then purec (if o<p.ports.f x q then tell o 0 1+1 else 0) |
| else if b=1 then |
| if i<p.steps.f x q then (1,p.dress.f x (q,o,i),tell o (i+1) (cord h w)+1) |
| else |
| let z:=p.scent.f x (q,w) |
| purec (going z (Jet.tug 1 (p.readyJ x (p.alpha.f x q,o)))+1) |
| else if b=2 then p.inprog x (q,o,w,h) |
| else purec 0 |
|
|
| def loom (x:Word)(a:Bean) := p.air x (a.1,dec a.2.1,a.2.2) |
| lemma airK : Kn p.air:= by |
| have hp:Kn (fun (_:Word)(a:Cover)=>a.2) :=Kn.next |
| have h:Kn (fun (_:Word)(a:Cover)=>a.1) :=Kn.first |
| have hv:=hp.left |
| have hb:=hv.left |
| have ho:=hv.right.left |
| have hi:=hv.right.right.left |
| have hw:=hv.right.right.right |
| exact hb.cond_eq (Kn.fix 0) |
| (pureK _ (ho.cond_lt (p.ports.runs.comp h) |
| ((cnameK _ _ _ _ (Kn.fix 1) ho (Kn.fix 0) (Kn.fix 1)).succ) (Kn.fix 0))) |
| (hb.cond_eq (Kn.fix 1) |
| (hi.cond_lt (p.steps.runs.comp h) |
| ((Kn.fix 1).tuple ((p.dress.runs.comp (h.tuple (ho.tuple hi))).tuple |
| ((cnameK _ _ _ _ (Kn.fix 1) ho hi.succ (hp.right.push hw)).succ))) |
| (pureK _ (goingK _ _ (p.scent.runs.comp (h.tuple hw)) (Jet.tugK _ _ (Kn.fix 1) |
| (p.readyK.comp ((p.alpha.runs.comp h).tuple ho)))))) |
| (hb.cond_eq (Kn.fix 2) |
| (p.progK.comp (h.tuple (ho.tuple (hw.tuple hp.right)))) |
| (Kn.fix _))) |
| lemma loomK : Kn p.loom:=p.airK.comp (Kn.first.tuple ((Kn.unpack.comp Kn.next.left).tuple Kn.next.right)) |
|
|
| / |
| def peel (v:Card):ℕ := |
| let f:=Jet.cap v.2.2.2 |
| if Jet.band f=2 then Jet.invp f else 0 |
| def peel0 (_:Word)(a:Bean):ℕ:= |
| let v:= (dec a.2.2:Card) |
| if v.1=2 then peel v else 0 |
| lemma peelK : Kn peel0:=by |
| let d (_:Word) (a:Bean):= (dec a.2.2:Card) |
| have he:Kn d:=Kn.unpack.comp Kn.next.right |
| have hf:= Jet.capK _ he.right.right.right |
| exact he.left.cond_eq (Kn.fix 2) |
| (hf.left.cond_eq (Kn.fix 2) hf.right.right.right.left (Kn.fix 0)) (Kn.fix 0) |
|
|
| def stripe0 (x:Word)(a:Bean):Bool := |
| let (q,v,i):=a |
| let t:= (dec v:Card).2.1 |
| if i=0 then if v=done t then true else if v=Sub.prime t then decide (t < p.ports.f x q) else false |
| else false |
| lemma stripeK : Kn p.stripe0:= by |
| let d (_:Word) (a:Bean):= (dec a.2.1:Card) |
| have he:Kn d:=Kn.unpack.comp Kn.next.left |
| have hi:Kn (fun (_:Word) (a:Bean)=>a.2):=Kn.next |
| have ht:=he.right.left |
| exact hi.right.cond_eq (Kn.fix 0) |
| (hi.left.cond_eq (cnameK _ _ _ _ (Kn.fix 3) ht (Kn.fix 0) (Kn.fix 0)) |
| (Kn.fix _) (hi.left.cond_eq (cnameK _ _ _ _ (Kn.fix 0) ht (Kn.fix 0) (Kn.fix 0)) |
| (ht.lt (p.ports.runs.comp Kn.first)) (Kn.fix _))) |
| (Kn.fix _) |
|
|
| def reader (x:Word)(a:Node) := p.loom x (a.1,a.2,0) |
| lemma readerK : Kn p.reader := p.loomK.comp (Kn.first.tuple (Kn.next.tuple (Kn.fix _))) |
|
|
| def Rune0 (p:Bow): Rune := |
| ⟨⟨fun x a=> (p.reader x a).1, p.readerK.left⟩,⟨fun x a=> (p.reader x a).2.1, p.readerK.right.left⟩, |
| ⟨fun x a=> (p.loom x a).2.2,p.loomK.right.right⟩, |
| ⟨_,peelK⟩,⟨_,p.stripeK⟩⟩ |
|
|
| end Bow |
| end ExactDerandomization.Sub |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Sub |
| open Relay Mint Swirl Counter |
|
|
| / |
| structure Quill where |
| b : Bow |
| v : Valve |
| s : Mill.Fuel |
| k : ℕ |
| A : ℕ |
| grit : ℕ→ℕ |
| bulk : ℕ→ℕ |
|
|
| namespace Quill |
| variable (u:Quill) |
| def p : Mill:=⟨u.A,u.b.Rune0,u.v⟩ |
| abbrev x0 :=u.s.l.x |
| abbrev q:=u.s.q |
| abbrev B:=u.p.O u.x0 u.q |
| abbrev H:=u.b.steps.f u.x0 u.q |
| abbrev child:=u.b.alpha.f u.x0 u.q |
| abbrev ceiling:=u.b.clipA.f u.x0 u.q |
|
|
| structure Tidy : Prop where |
| run : u.p.Fires u.s |
| gain : 100 ≤ u.k |
| reach : 1000*u.k^2 ≤ u.A |
| reserve : Mill.Reserve u.p u.s |
| gap0 : u.v.D.f u.x0 u.q=1 |
| early : u.H ≤ u.B.t+u.k |
| steady : u.grit u.child =1 |
| openR : u.bulk u.child≤u.B.w |
|
|
| def Cush (v i : ℕ) := lb v≤20*u.k*i ∧ i≤4*lb v |
| lemma leftP (a b:ℕ): lb a ≤ lb (enc (a,b)) :=lb_mono (cord_fine a _).2.1.le |
| lemma rightP (a b:ℕ): lb b ≤ lb (enc (a,b)) :=lb_mono (le_trans (by omega: b≤b+1) (cord_fine a _).1.le) |
|
|
| lemma cname_l (b p i s) : |
| lb (cname b p i s) ≤2*(lb b+lb p+lb i)+lb s+6 ∧ |
| lb p ≤ lb (cname b p i s) ∧ lb s ≤ lb (cname b p i s):= by |
| let v : ℕ:=enc ((i,s):ℕ×ℕ) |
| let w : ℕ:=enc ((p,v):ℕ×ℕ) |
| have hp: w=enc (p,i,s):=rfl |
| have hz: cname b p i s=enc (b,w):=rfl |
| rw [hz] |
| have he : lb w≤2*lb p+lb v+2:=measure_pair _ _ |
| have hs : lb v≤2*lb i+lb s+2:=measure_pair _ _ |
| have ht : lb (enc (b,w)) ≤ 2*lb b+lb w+2:=measure_pair _ _ |
| have hy : lb p≤lb w:=leftP p v |
| have hy2:=rightP b w; have hy3 : lb v≤lb w:=rightP p v; have hy4 : lb s≤lb v:=rightP i s |
| omega |
|
|
| lemma inProgG {k : ℕ} {label S} (h:u.Tidy) |
| (hv: u.H≤ lb label) (he: lb label ≤ u.k*(u.H+1)) (ht:k≤ lb S) (hs:lb S ≤ 1+4*u.k*k) : |
| u.Cush (going label S) (u.H+k+1) :=by |
| have hp:=h.gain |
| obtain ⟨h1,h2,h3⟩:=cname_l 2 label 0 S |
| have hc : lb 2=2:=rfl |
| rw [hc,lb_zero] at h1 |
| change _ ≤ _ at ht |
| unfold Cush going; constructor |
| · nlinarith |
| have hz:=lb_pos (cname 2 label 0 S) |
| omega |
|
|
| lemma capDone {z} (h:u.Tidy) (hv:u.H≤lb z) (he:lb z≤u.k*(u.H+1)): |
| u.Cush (done z) (u.H+1):= by |
| obtain ⟨h1,h2,h3⟩:=cname_l 3 z 0 0 |
| have hu : lb 3=2:=rfl |
| rw [lb_zero,hu] at h1; have hp:=h.gain |
| unfold Cush done; constructor |
| · nlinarith |
| have hz:=lb_pos (cname 3 z 0 0); omega |
| lemma capPrime {p} (h:u.Tidy) (he:lb p≤u.k):u.Cush (prime p) 1:= by |
| obtain ⟨h1,h2,h3⟩:=cname_l 0 p 0 0 |
| rw [lb_zero] at h1 |
| have hp:=h.gain; unfold Cush prime |
| have hz:=lb_pos (cname 0 p 0 0); omega |
| lemma capTell {p i s} (h:u.Tidy) (he:lb p≤u.k) |
| (hy:i+1≤lb s)(hz:lb s ≤1+3*u.k*i):u.Cush (tell p i s) (i+1):= by |
| obtain ⟨h1,h2,h3⟩:=cname_l 1 p i s |
| rw [lb_one] at h1 |
| have hp:=h.gain |
| have hh:=lb_le_inc i |
| unfold Cush tell; constructor |
| · nlinarith |
| omega |
|
|
| lemma prepaid {v i} (h:u.Tidy) (e:u.Cush v i) (he:i≤u.H+u.B.w+1): |
| lb v≤Mill.prize u.p u.s := by |
| have hw : 1≤u.B.w:=h.run.wp |
| have hh:= h.early; have hz:=h.gain; have ht:=h.reach |
| obtain ⟨he1,he2⟩:=e |
| have h1 : i≤u.B.t+ (u.k+2)*u.B.w :=by nlinarith |
| change lb v ≤ charge u.A u.B.w u.B.t |
| have h2 : 20*u.k*(u.k+2) ≤ u.A*u.A:=by |
| have hz : 10*u.k ≤ u.A:=by nlinarith |
| nlinarith [Nat.mul_le_mul hz hz] |
| have h3 : 20*u.k≤ u.A:=by nlinarith |
| unfold charge |
| nlinarith [Nat.mul_le_mul_right u.B.w h2,Nat.mul_le_mul_right u.B.t h3,Nat.mul_le_mul_left (20*u.k) h1] |
|
|
| lemma team0 {v i w j} (h:u.Tidy) (hv:u.Cush v i) (hw:u.Cush w j) (he:i≤4*j) : |
| lb v≤lb w*u.A:= by |
| have ha:=h.gain; have he1:=h.reach |
| have h2:i≤16*lb w:=by have hp:=hw.2; omega |
| have h3:20*u.k*16 ≤ u.A:=by nlinarith |
| have hz:=hv.1 |
| nlinarith [Nat.mul_le_mul_right (lb w) h3,Nat.mul_le_mul_left (20*u.k) h2] |
| lemma team {v i w j} (h:u.Tidy) (hv:u.Cush v i) (hw:u.Cush w j) (hi:i≤u.H+u.B.w+1) |
| (hj:j≤u.H+u.B.w+1)(he:i≤4*j) (hf:j≤4*i): |
| Mill.fitting u.p u.s v w := ⟨u.prepaid h hv hi,u.prepaid h hw hj,u.team0 h hv hw he,u.team0 h hw hv hf⟩ |
|
|
| lemma structure_pay {v i f} (h:u.Tidy) (hv:u.Cush v i) |
| (he:i≤u.H+(u.B.w-u.v.depth.f u.x0 f)+1) |
| (ht:u.v.depth.f u.x0 f+1 ≤ u.B.w) (hh:u.v.clock.f u.x0 f=0) : |
| Mill.faith u.p u.s v f := by |
| let x:=u.B.w-u.v.depth.f u.x0 f; have hx:1≤x:=by dsimp only [x]; omega |
| have hz:=h.gain; have hg:=h.reach |
| change _+_≤_ ∧ span u.A x u.B.t (u.v.clock.f u.x0 f) (lb v+1) |
| refine ⟨by change u.v.depth.f u.x0 f+u.v.D.f u.x0 u.q≤_; rw [h.gap0]; exact ht,?_⟩ |
| rw [hh] |
| have hp:=hv.1 |
| have h1:i≤u.B.t+(u.k+2)*x:=by have hh1:=h.early; change i≤u.H+x+1 at he; nlinarith |
| have h2:20*u.k≤u.A:=by nlinarith |
| have h3:20*u.k*(u.k+2)+1≤u.A*u.A:=by nlinarith |
| unfold span; nlinarith [Nat.mul_le_mul_right u.B.t h2,Nat.mul_le_mul_right x h3,Nat.mul_le_mul_left (20*u.k) h1] |
|
|
| lemma score_pay {v i f}(h:u.Tidy)(hv:u.Cush v (i+1)) |
| (he:i+u.v.clock.f u.x0 f≤ u.B.t+u.k) (hs:u.v.depth.f u.x0 f+1≤u.B.w): |
| Mill.faith u.p u.s v f := by |
| let x:=u.B.w-u.v.depth.f u.x0 f; have hx:1≤x:=by dsimp only [x]; omega |
| have hp:=h.reach; have hg:=h.gain |
| change _+_≤_ ∧ span u.A x u.B.t (u.v.clock.f u.x0 f) (lb v+1) |
| refine ⟨by change u.v.depth.f u.x0 f+u.v.D.f u.x0 u.q≤_; rw [h.gap0]; exact hs,?_⟩ |
| have hz:=hv.1; have h1:20*u.k≤u.A:=by nlinarith |
| have h2:u.k+2≤u.A:=by nlinarith |
| have ht : u.A*(u.k+2) ≤ u.A*u.A*x := by |
| have hm:u.A*(u.k+2) ≤ u.A*u.A:= Nat.mul_le_mul_left u.A h2 |
| nlinarith [Nat.mul_le_mul_left (u.A*u.A) hx] |
| unfold span; nlinarith [Nat.mul_le_mul_left u.A he,Nat.mul_le_mul_right (i+1) h1] |
|
|
| end Quill |
| end ExactDerandomization.Sub |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Sub |
| open Relay Mint Swirl Counter |
| namespace Quill |
| variable (u:Quill) |
|
|
| abbrev Cr (x y : Swirl.Dot) := u.p.minted u.s x y |
| abbrev Track := Relation.ReflTransGen u.Cr |
|
|
| abbrev Aq (b p i s : ℕ) (j) := u.b.air u.x0 (u.q,(b,p,i,s),j) |
| lemma Ax (b p i s j) : u.b.loom u.x0 (u.q,cname b p i s,j) = u.Aq b p i s j := by simp [Aq,Bow.loom] |
| lemma deco (b p i s): |
| u.p.compo u.s (cname b p i s)= (u.Aq b p i s 0).1 := |
| congrArg (fun x=>x.1) (u.Ax b p i s 0) |
| lemma tripk (b p i s) : u.p.slipk u.s (cname b p i s)=(u.Aq b p i s 0).2.1 := |
| congrArg (fun x=>x.2.1) (u.Ax b p i s 0) |
| lemma stable (b p i s t v) : u.p.label u.s (cname b p i s) v t=(u.Aq b p i s t).2.2 := |
| congrArg (fun x=>x.2.2) (u.Ax b p i s t) |
|
|
| abbrev garnish (p i) := u.b.dress.f u.x0 (u.q,p,i) |
| def chainR (p c:ℕ) (i:ℕ):ℕ := forNat (fun k v=> cord (u.s.echo (u.garnish p k) c) v) 1 i |
| lemma chain_next (p c i) : u.chainR p c (i+1)=cord (u.s.echo (u.garnish p i) c) (u.chainR p c i):=rfl |
| abbrev scent (p c) := u.b.scent.f u.x0 (u.q,u.chainR p c u.H) |
|
|
| def Stringent (z:ℕ):=u.H ≤ lb z ∧ lb z ≤ u.k*(u.H+1) |
|
|
| structure Gown (p c:ℕ):Prop where |
| lengthp : lb p≤ u.k |
| known : p < u.b.ports.f u.x0 u.q |
| lens : ∀ i < u.H,lb (u.s.echo (u.garnish p i) c) ≤ u.k |
| law0 : ∀ i < u.H, i+u.v.clock.f u.x0 (u.garnish p i) ≤ u.B.t+u.k ∧ |
| u.v.depth.f u.x0 (u.garnish p i)+1 ≤ u.B.w ∧ |
| u.v.tap.f u.x0 (u.garnish p i)=true |
| hair : u.Stringent (u.scent p c) |
|
|
| lemma chain_size {p c} (h:u.Tidy)(e:u.Gown p c){i}(hi:i≤u.H) : |
| i+1 ≤ lb (u.chainR p c i) ∧ lb (u.chainR p c i) ≤1+3*u.k*i ∧ 1≤u.chainR p c i:= by |
| induction i with |
| | zero=>change 0+1≤lb 1 ∧ lb 1≤_ ∧ 1≤1; rw [lb_one]; omega |
| | succ i ih=> |
| rw [u.chain_next]; obtain ⟨ha,hb,hc⟩:=ih (by omega) |
| have hz:=lb_cord (u.s.echo (u.garnish p i) c) _ hc |
| rw [hz] |
| have hw:= lb_pos (u.s.echo (u.garnish p i) c) |
| have hk:= e.lens i hi |
| have hf:= h.gain |
| refine ⟨by omega,by nlinarith,(cord_fine ..).2.2.le⟩ |
|
|
| lemma pointing {p c i} (h:u.Tidy)(e:u.Gown p c) (hi:i≤u.H): |
| u.Cush (tell p i (u.chainR p c i)) (i+1) := |
| let hk:= u.chain_size h e hi |
| u.capTell h e.lengthp hk.1 hk.2.1 |
|
|
| lemma prepared {p c}(h:u.Tidy) (g:u.Gown p c)(he:c∈u.s.domain): |
| u.Track (prime p,c) (tell p u.H (u.chainR p c u.H),c):=by |
| have e0: u.Cr (prime p,c) (tell p 0 1,c):=by |
| have hk0 := u.pointing h g (Nat.zero_le _) |
| change u.Cush (tell p 0 1) (0+1) at hk0 |
| apply u.p.meets0 u.s h.reserve |
| (u.team h (u.capPrime h g.lengthp) hk0 (by omega) (by omega) (by omega) (by omega)) _ _ he |
| · rw [u.deco]; rfl |
| rw [u.stable]; simp [Aq,Bow.air,g.known,Bow.purec] |
| suffices h:∀ i≤ u.H,u.Track (prime p,c) (tell p i (u.chainR p c i),c) by exact h _ le_rfl |
| intro i hi |
| induction i with |
| | zero=> exact Relation.ReflTransGen.single e0 |
| | succ i ih=> |
| apply Relation.ReflTransGen.tail (ih (by omega)) |
| have hz:=u.pointing h g (show i≤u.H by omega); let w:=tell p i (u.chainR p c i) |
| have hi': i < u.b.steps.f u.x0 u.q:=hi |
| have hp0:u.p.slipk u.s w=u.garnish p i:=by unfold w; rw [u.tripk]; simp [Aq,Bow.air,hi',garnish] |
| apply u.p.meets1 u.s h.reserve (u.team h hz (u.pointing h g hi) (by omega) (by omega) (by omega) (by omega)) _ _ _ he |
| · rw [u.deco]; simp [Aq,Bow.air,hi'] |
| · have hx:=hp0; unfold w at hx |
| rw [hx,u.stable] |
| simp [Aq,Bow.air,hi',u.chain_next] |
| · obtain ⟨ha,hb,hc⟩:= g.law0 i hi |
| change u.p.afoot u.s w |
| unfold Mill.afoot; rw [hp0] |
| exact ⟨hc,u.score_pay h hz ha hb⟩ |
|
|
| lemma shut {p c} : u.p.mate u.s (done p,c) := by |
| apply u.p.cinder0 |
| · rw [u.deco]; rfl |
| intro i; rw [u.stable]; rfl |
| lemma different {a b c} : going a b≠done c:= by |
| intro he |
| have hc:= congrArg (fun x=> (dec x:Card).1) he |
| simp [going,done] at hc |
|
|
| end Quill |
| end ExactDerandomization.Sub |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Sub |
| open Relay Mint Swirl Counter |
| namespace Quill |
| variable (u:Quill) |
|
|
| abbrev fill (a p) := u.b.readyJ u.x0 (a,p) |
| abbrev hear (a p) := u.b.ask.f u.x0 (a,p) |
| abbrev tagH (a p h:ℕ):Bean:=(a,p,h) |
| abbrev callB (a p h) := u.b.before.f u.x0 (tagH a p h) |
| abbrev callP (a p h) := u.b.knot.f u.x0 (tagH a p h) |
| abbrev lower (a p h) := u.b.other.f u.x0 (tagH a p h) |
| abbrev portD (a p h) := u.b.passp.f u.x0 (tagH a p h) |
| abbrev dives (a p h) := u.b.haskid.f u.x0 (tagH a p h) |
| def kidJ (a p h e b:ℕ) : Jet:= (u.fill a p).jik b h e |
| lemma turnkid (a p h e b g):Jet.turn (u.kidJ a p h e b) g=u.kidJ a p h e g := rfl |
|
|
| def calm (a t:ℕ):= u.v.clock.f u.x0 t=0 ∧ u.v.depth.f u.x0 t+u.grit a ≤ u.bulk a |
|
|
| def Orders (a q v:ℕ):Prop := |
| u.v.voted.f u.x0 (q,v)=true ∧ ∀ b,u.calm a ((u.v.reach b).f u.x0 (q,v)) |
|
|
| def little (a:ℕ) (f:Jet) := |
| u.grit a≤lb (enc f) ∧ lb (enc f) ≤u.k*u.grit a |
|
|
| structure Rating (a p:ℕ) : Prop where |
| insured : a≤u.ceiling |
| positive : 1≤u.grit a |
| reach : u.grit a ≤ u.bulk a |
| littleR : u.little a (u.fill a p) |
| get : u.v.tap.f u.x0 (u.hear a p)=true |
| heat : u.calm a (u.hear a p) |
|
|
| structure Bolts (a p h e :ℕ) : Prop where |
| before0 : u.little a (u.kidJ a p h 0 1) |
| passed : ∀ i ≤ 5, u.little a (u.kidJ a p h e i) |
| forward0 : u.Orders a (u.callB a p h) e |
| post : u.Orders a (u.callP a p h) 0 |
|
|
| / |
| validity bit. -/ |
| structure Chess (a p h e c z y w:ℕ) : Prop where |
| hr : u.Rating a p |
| kin : u.Bolts a p h e |
| hx : c∈u.s.domain |
| hz : z∈u.s.domain |
| hy : y∈u.s.domain |
| hw : w∈u.s.domain |
| chosen : u.s.echo (u.hear a p) c=h |
| extant : h≠0 |
| peak : u.s.stream (u.callB a p h) e true c=some z |
| erode : u.s.stream (u.callP a p h) 0 true y=some w |
|
|
| / |
| inductive Herd : ℕ→ℕ→ℕ→ℕ→ℕ→ℕ→Prop |
|
|
| | solo {a p h e c z w} (h0:u.Chess a p h e c z z w) (hd:u.dives a p h=false): |
| Herd a p c h e w |
| | pair {a p h e c z y w f g} (hr:u.Chess a p h e c z y w) (hv:u.dives a p h=true) |
| (hd:u.bulk (u.lower a p h)+u.grit a ≤ u.bulk a) |
| (hy:u.grit (u.lower a p h) ≤ 2*u.grit a) |
| (he:Herd (u.lower a p h) (u.portD a p h) z f g y): |
| Herd a p c h e w |
|
|
| lemma Herd.on {u:Quill} {a p c h e w} (hh:u.Herd a p c h e w) : |
| u.Rating a p ∧ u.Bolts a p h e:=by cases hh with | solo h0 _=> exact ⟨h0.hr,h0.kin⟩ | pair hr _ _ _ _=>exact ⟨hr.hr,hr.kin⟩ |
|
|
| inductive Lane (a p c:ℕ) : Option ℕ→Prop |
| | dry (hr:u.Rating a p) (hc:c∈u.s.domain) (hh:u.s.echo (u.hear a p) c=0) : |
| Lane a p c none |
| | born {h e w} (hs:u.Herd a p c h e w) : Lane a p c (some w) |
|
|
| abbrev wagon (l:List ℕ)(f:Jet) := mesh (enc f::l) |
| lemma wagon_eq (l f) : wagon l f=Jet.tug (mesh l) f:= rfl |
| def cart (o:ℕ)(l:List ℕ)(f:Jet) := going o (wagon l f) |
|
|
| structure Course (l:List ℕ) (a m:ℕ):Prop where |
| dimensional : m+u.bulk a ≤ u.B.w |
| room0 : m ≤ lb (mesh l) |
| room1 : lb (mesh l) ≤ 1+4*u.k*m |
| link : Scan u.ceiling (fun j k=> u.b.along u.x0 ((u.q,0),j,k)) u.child l.reverse a |
|
|
| lemma coal {l a m p o f} (h:u.Tidy)(hx:u.Rating a p)(hh:u.Course l a m) |
| (hv:u.little a f)(hz:u.Stringent o): |
| u.Cush (cart o l f) (u.H+(m+u.grit a)+1) := by |
| apply inProgG u h hz.1 hz.2 |
| · rw [wagon, measure_mesh]; have := hv.1; have := hh.room0; omega |
| · rw [wagon, measure_mesh]; have := hv.2; have := hh.room1 |
| have he:=hx.positive; have hp:=h.gain |
| nlinarith |
|
|
| lemma rag {l a m p} (hx:u.Rating a p)(hh:u.Course l a m) : |
| u.H+(m+u.grit a)+1 ≤ u.H+u.B.w+1:=by |
| have he:=hx.reach; have hz:=hh.dimensional; omega |
|
|
| lemma aloft {l a m} (hh:u.Course l a m): |
| u.b.journey u.x0 (u.q,mesh l)=a:= by |
| unfold Bow.journey |
| exact exact_sweep (l:=l.reverse) hh.link (windback_mesh ..) |
|
|
| lemma goto {l a m p h t} {f:Jet} (ht:u.Tidy)(hp:u.Rating a p) |
| (hz:u.Course l a m) (hy:u.Rating (u.lower a p h) t) |
| (he:u.bulk (u.lower a p h)+u.grit a ≤ u.bulk a) |
| (hi:u.little a f) (hh:Jet.rune f=h)(hk:Jet.port f=p): |
| u.Course (enc f::l) (u.lower a p h) (m+u.grit a) := by |
| obtain ⟨h1,h2,h3,h4⟩:=hz |
| refine ⟨by omega,?_,?_,?_⟩ |
| · rw [measure_mesh]; have hz:=hi.1; omega |
| · rw [measure_mesh]; have hz:=hi.2; have hg:=ht.gain; have hh:=hp.positive |
| nlinarith |
| rw [List.reverse_cons] |
| exact Grid.Scan.snatch h4 (by |
| simp [Bow.along,Bow.hint,hk,hh,lower,tagH]) hy.insured |
|
|
| lemma price1 {l a m p t} (hx:u.Rating a p)(hh:u.Course l a m) (hz:u.calm a t) : |
| u.v.depth.f u.x0 t+1≤u.B.w ∧ |
| u.H+(m+u.grit a)+1 ≤ u.H+(u.B.w-u.v.depth.f u.x0 t)+1:= by |
| have he:=hx.positive; have hv:=hh.dimensional; have ha:=hz.2; omega |
|
|
| lemma timeok {t l a m p f o} (h:u.Tidy)(hx:u.Rating a p)(he:u.Course l a m) |
| (hy:u.little a f) (ho:u.Stringent o) |
| (hh:u.calm a t): Mill.faith u.p u.s (cart o l f) t := |
| let hz:=u.price1 hx he hh |
| u.structure_pay h (u.coal h hx he hy ho) hz.2 hz.1 hh.1 |
|
|
| lemma ae {l o i f} : |
| u.b.loom u.x0 (u.q,cart o l f,i) = u.b.inprog u.x0 (u.q,o,wagon l f,i):= |
| u.Ax 2 o 0 (wagon l f) i |
|
|
| lemma resultv {l o i f m a} (he:u.Course l a m): |
| u.b.loom u.x0 (u.q,cart o l f,i) = |
| let t:=mesh l |
| let v:=f |
| let α:=a |
| let _:=u.q |
| let x:=u.x0 |
| let H:= Bow.hint α v |
| let p:=u.b |
| let work := fun z=> going o (Jet.tug t z)+1 |
| if Jet.band v=0 then (1,p.ask.f x (α,Jet.port v), if i=0 then 0 else work (Jet.jik v 1 i 0)) |
| else if Jet.band v=1 then (2,p.before.f x H,work (Jet.jik v 2 (Jet.rune v) i)) |
| else if Jet.band v=2 then |
| if p.haskid.f x H then |
| Bow.purec (going o (Jet.tug (Jet.tug t (Jet.turn v 3)) (p.readyJ x (p.other.f x H,p.passp.f x H)))+1) |
| else Bow.purec (work (Jet.turn v 4)) |
| else if Jet.band v=4 then (2,p.knot.f x H,work (Jet.turn v 5)) |
| else if Jet.band v=5 then |
| if t≤1 then Bow.purec (done o+1) |
| else Bow.purec (going o (Jet.tug (aft t) (Jet.turn (Jet.cap t) 4))+1) |
| else Bow.purec 0:=by |
| rw [u.ae]; simp only [Bow.inprog,wagon_eq,Jet.cap_tug,Jet.aft_tug,u.aloft he] |
|
|
| end Quill |
| end ExactDerandomization.Sub |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Sub |
| open Relay Mint Swirl Counter Relation |
| namespace Quill |
| variable (u:Quill) |
|
|
| lemma taking {l a m p o v w}(ht:u.Tidy)(hp:u.Rating a p) |
| (hx:u.Course l a m)(hy:u.Stringent o) (hz:u.little a v)(hh:u.little a w): |
| Mill.fitting u.p u.s (cart o l v) (cart o l w):= |
| u.team ht (u.coal ht hp hx hz hy) (u.coal ht hp hx hh hy) (u.rag hp hx) (u.rag hp hx) (by omega) (by omega) |
|
|
| abbrev future1 (o:ℕ)(l:List ℕ)(f:Jet) :ℕ:= cart o l f+1 |
| lemma future_eq (o l f): future1 o l f=going o (Jet.tug (mesh l) f)+1:=rfl |
|
|
| lemma ore0 {l a m} (hp:u.Course l a m) (o p i:ℕ): |
| u.b.loom u.x0 (u.q,cart o l (u.fill a p),i)= |
| (1,u.hear a p,if i=0 then 0 else future1 o l (u.kidJ a p i 0 1)):=by |
| rw [u.resultv hp]; simp only [Jet.band,fill,Bow.readyJ,ite_true]; rfl |
| lemma ore1 {l a m} (hp:u.Course l a m) (o p h i:ℕ): |
| u.b.loom u.x0 (u.q,cart o l (u.kidJ a p h 0 1),i)= |
| (2,u.callB a p h, future1 o l (u.kidJ a p h i 2)):= by |
| rw [u.resultv hp]; simp only [kidJ,Jet.band,Jet.jik,OfNat.one_ne_ofNat,one_ne_zero,ite_false,ite_true]; rfl |
| lemma ore4 {l a m} (hp:u.Course l a m) (o p h e i:ℕ): |
| u.b.loom u.x0 (u.q,cart o l (u.kidJ a p h e 4),i)= |
| (2,u.callP a p h, future1 o l (u.kidJ a p h e 5)):=by |
| rw [u.resultv hp]; rfl |
|
|
| lemma pairTok2 (a p h e o:ℕ) (l:List ℕ) (v) : |
| u.p.wherep u.s v (cart o l (u.kidJ a p h e 2)) = e:=by |
| change Bow.peel0 u.x0 (_, _, cart ..) = _ |
| simp [Bow.peel0,Bow.peel, cart,going,wagon_eq,kidJ,Jet.jik,Jet.band,Jet.invp] |
| lemma pairTok5 (a p h e o:ℕ)(l:List ℕ) (v): |
| u.p.wherep u.s v (cart o l (u.kidJ a p h e 5))=0:=by |
| change Bow.peel0 u.x0 (_, _, cart ..) = _ |
| simp [Bow.peel0,Bow.peel,cart,going,wagon_eq,kidJ,Jet.jik,Jet.band] |
|
|
| lemma first0 {l a m p o c} (_:u.Tidy)(_:u.Rating a p)(hc:u.Course l a m)(_:u.Stringent o) |
| (he:u.s.echo (u.hear a p) c=0): |
| u.p.mate u.s (cart o l (u.fill a p),c):= by |
| apply u.p.cinder1 |
| · exact congrArg Prod.fst (u.ore0 hc o p 0) |
| intro i |
| have hS: u.p.slipk u.s (cart o l (u.fill a p))=u.hear a p:= |
| congrArg (fun x=> x.2.1) (u.ore0 hc o p 0) |
| rw [hS,he] |
| exact congrArg (fun x=>x.2.2) (u.ore0 hc o p 0) |
|
|
| lemma helm {l a m p o h e c z y w} (ht:u.Tidy)(hp:u.Chess a p h e c z y w) |
| (hx:u.Course l a m)(ho:u.Stringent o): |
| u.Cr (cart o l (u.fill a p),c) (cart o l (u.kidJ a p h 0 1),c):= by |
| let v:=cart o l (u.fill a p) |
| have h1:=u.ore0 hx o p |
| have hs:u.p.slipk u.s v=u.hear a p:=congrArg (fun x=>x.2.1) (h1 0) |
| change u.Cr (v,c) _ |
| apply u.p.meets1 u.s ht.reserve (u.taking ht hp.hr hx ho hp.hr.littleR hp.kin.before0) ?_ ?_ ?_ hp.hx |
| · exact congrArg Prod.fst (h1 0) |
| · rw [hs,hp.chosen] |
| exact (congrArg (fun x=>x.2.2) (h1 h)).trans (ite_eq_right hp.extant) |
| unfold Mill.afoot; rw [hs] |
| exact ⟨hp.hr.get, u.timeok ht hp.hr hx hp.hr.littleR ho hp.hr.heat⟩ |
|
|
| lemma swift0 {l a m p f o t r} (ht:u.Tidy)(hr:u.Rating a p) |
| (hx:u.Course l a m) (hv:u.little a f) (ho:u.Stringent o) |
| (he:u.p.slipk u.s (cart o l f)=t)(h:u.Orders a t r): |
| u.p.swift u.s (cart o l f) r:=by |
| unfold Mill.swift Mill.swept; rw [he] |
| exact ⟨h.1,fun b=>u.timeok ht hr hx hv ho (h.2 b)⟩ |
|
|
| lemma prowl {l a m p o h e c z y w} (ht:u.Tidy)(hp:u.Chess a p h e c z y w) |
| (hx:u.Course l a m)(ho:u.Stringent o): |
| u.Cr (cart o l (u.kidJ a p h 0 1),c) (cart o l (u.kidJ a p h e 2),z):=by |
| let f:=u.kidJ a p h 0 1 |
| let v:=cart o l f; have hq:=u.ore1 hx o p h |
| have hs:u.p.slipk u.s v=u.callB a p h:=congrArg (fun x=>x.2.1) (hq 0) |
| change u.Cr (v,c) _ |
| apply u.p.meets2 u.s ht.reserve (u.taking ht hp.hr hx ho hp.kin.before0 (hp.kin.passed 2 (by omega))) |
| (congrArg Prod.fst (hq 0)) (u.pairTok2 ..).symm (congrArg (fun x=>x.2.2) (hq e)) |
| (u.swift0 ht hp.hr hx hp.kin.before0 ho hs hp.kin.forward0) hp.hx hp.hz |
| rw [hs] |
| exact hp.peak |
|
|
| lemma shiver {l a m p o h e c z y w} (ht:u.Tidy)(hp:u.Chess a p h e c z y w) |
| (hx:u.Course l a m)(ho:u.Stringent o): |
| u.Cr (cart o l (u.kidJ a p h e 4),y) (cart o l (u.kidJ a p h e 5),w):=by |
| let f:=u.kidJ a p h e 4; let v:=cart o l f; have hq:=u.ore4 hx o p h e |
| have hs:u.p.slipk u.s v=u.callP a p h:=congrArg (fun x=>x.2.1) (hq 0) |
| change u.Cr (v,y) _ |
| apply u.p.meets2 u.s ht.reserve |
| (u.taking ht hp.hr hx ho (hp.kin.passed 4 (by omega)) (hp.kin.passed 5 (by omega))) |
| (congrArg Prod.fst (hq 0)) (u.pairTok5 ..).symm (congrArg (fun x=>x.2.2) (hq 0)) |
| (u.swift0 ht hp.hr hx (hp.kin.passed 4 (by omega)) ho hs hp.kin.post) hp.hy hp.hw |
| rw [hs]; exact hp.erode |
|
|
| end Quill |
| end ExactDerandomization.Sub |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Sub |
| open Relay Mint Swirl Counter Relation |
| namespace Quill |
| variable (u:Quill) |
| private abbrev nextJ (u:Quill) (a p h e) := enc (u.kidJ a p h e 3) |
| lemma ore2 {l a m} (hp:u.Course l a m) (o p h e i:ℕ): |
| u.b.loom u.x0 (u.q,cart o l (u.kidJ a p h e 2),i)= |
| if u.dives a p h then |
| Bow.purec (future1 o (nextJ u a p h e::l) (u.fill (u.lower a p h) (u.portD a p h))) |
| else Bow.purec (future1 o l (u.kidJ a p h e 4)):= by |
| rw [u.resultv hp] |
| unfold kidJ Jet.band Jet.jik; rfl |
|
|
| lemma blink0 {v i z}(ht:u.Tidy)(h:u.b.loom u.x0 (u.q,v,0)=Bow.purec (i+1)) |
| (he:u.p.fitting u.s v i) (hh:z∈u.s.domain): u.Cr (v,z) (i,z) := |
| u.p.meets0 u.s ht.reserve he (congrArg Prod.fst h) (congrArg (fun x=>x.2.2) h) hh |
|
|
| lemma downfit {l S a m alpha p p' o v w}(ht:u.Tidy)(hp:u.Rating a p) |
| (hx:u.Course l a m)(hy:u.Stringent o) (hz:u.little a v) |
| (hr:u.Rating alpha p')(hk:u.Course S alpha (m+u.grit a)) |
| (hm:u.little alpha w) (hh:u.grit alpha ≤2*u.grit a): |
| Mill.fitting u.p u.s (cart o l v) (cart o S w) := |
| u.team ht (u.coal ht hp hx hz hy) (u.coal ht hr hk hm hy) (u.rag hp hx) (u.rag hr hk) |
| (by omega) (by omega) |
|
|
| lemma pop5 {l f a m} (hp:u.Course (enc f::l) a m) |
| (o p h g i:ℕ): u.b.loom u.x0 (u.q,cart o (enc f::l) (u.kidJ a p h g 5),i)= |
| Bow.purec (future1 o l (Jet.turn f 4)) := by |
| rw [u.resultv hp] |
| suffices he : |
| (if mesh (enc f::l)≤1 then Bow.purec (done o+1) |
| else Bow.purec (going o |
| (Jet.tug (aft (mesh (enc f::l))) (Jet.turn (Jet.cap (mesh (enc f::l))) 4)) +1)) |
| = Bow.purec (future1 o l (Jet.turn f 4)) by |
| convert he using 1 |
| rfl |
| change (if Jet.tug (mesh l) f≤1 then _ else _)=_ |
| have he1 : ¬Jet.tug (mesh l) f≤1:=not_le_of_gt (cord_fine ..).2.2 |
| rw [ite_eq_right he1] |
| change Bow.purec (going o (Jet.tug (aft (Jet.tug (mesh l) f)) (Jet.turn (Jet.cap (Jet.tug (mesh l) f)) 4))+1)=_ |
| rw [Jet.aft_tug,Jet.cap_tug]; rfl |
|
|
| lemma popped_only {a} (hp:u.Course [] a 0) (o p h g): |
| u.b.loom u.x0 (u.q,cart o [] (u.kidJ a p h g 5),0)=Bow.purec (done o+1):=by rw [u.resultv hp]; rfl |
|
|
| lemma reverse_fit (p:Mill)(s:Mill.Fuel){v w}(h:p.fitting s v w):p.fitting s w v:= |
| ⟨h.2.1,h.1,h.2.2.2,h.2.2.1⟩ |
|
|
| lemma flagdown {l a m p h e o c z y w}(ht:u.Tidy)(hp:u.Chess a p h e c z y w) |
| (hx:u.Course l a m) (ho:u.Stringent o) (hy:u.dives a p h=false): |
| u.Cr (cart o l (u.kidJ a p h e 2),z) (cart o l (u.kidJ a p h e 4),z):= |
| u.blink0 ht ((u.ore2 hx o p h e 0).trans (ite_eq_right (by simp [hy]))) |
| (u.taking ht hp.hr hx ho (hp.kin.passed 2 (by omega)) (hp.kin.passed 4 (by omega))) hp.hz |
|
|
| lemma ladder {a m p l o h e c w} (ht:u.Tidy) (hp:u.Herd a p c h e w) |
| (hx:u.Course l a m) (ho:u.Stringent o): |
| u.Track (cart o l (u.fill a p),c) (cart o l (u.kidJ a p h e 5),w) := by |
| induction hp generalizing l m with |
| | solo hr h1=> |
| exact ReflTransGen.tail (.tail (.tail (.single (u.helm ht hr hx ho)) (u.prowl ht hr hx ho)) |
| (u.flagdown ht hr hx ho h1)) (u.shiver ht hr hx ho) |
| | @pair a p h e c z y w f g hr hv hd hy he ih=> |
| let S:= nextJ u a p h e :: l |
| obtain ⟨hf,hh⟩:=he.on |
| have hy' : u.Course S (u.lower a p h) (m+u.grit a) := |
| u.goto ht hr.hr hx hf hd (hr.kin.passed 3 (by omega)) rfl rfl |
| have ht1:= ih hy' |
| have hu0:= u.ore2 hx o p h e 0 |
| have hs:= u.downfit ht hr.hr hx ho (hr.kin.passed 2 (by omega)) hf hy' hf.littleR hy |
| have hs2:= u.downfit ht hr.hr hx ho (hr.kin.passed 4 (by omega)) hf hy' (hh.passed 5 (by omega)) hy |
| have hp1: u.Cr (cart o l (u.kidJ a p h e 2),z) (cart o S (u.fill (u.lower a p h) (u.portD a p h)),z):= |
| u.blink0 ht (hu0.trans (ite_eq_left hv)) hs hr.hz |
| have hp5:u.b.loom u.x0 (u.q,cart o S (u.kidJ (u.lower a p h) (u.portD a p h) f g 5),0)= |
| Bow.purec (future1 o l (u.kidJ a p h e 4)):= |
| u.pop5 hy' o (u.portD a p h) f g 0 |
| have hpf := u.blink0 ht hp5 (reverse_fit _ _ hs2) hr.hy |
| exact .tail (.tail ((ReflTransGen.tail (.tail (.single (u.helm ht hr hx ho)) |
| (u.prowl ht hr hx ho)) hp1).trans ht1) hpf) (u.shiver ht hr hx ho) |
|
|
| lemma dawn {p}(ht:u.Tidy)(he:u.Rating u.child p): |
| u.Course [] u.child 0:=⟨by simpa using ht.openR,Nat.zero_le _,by change lb 1≤_; rw [lb_one]; omega, |
| .nil he.insured⟩ |
|
|
| lemma cool {p c}(ht:u.Tidy)(he:u.Gown p c)(hk:u.Rating u.child p)(hx:c∈u.s.domain): |
| u.Track (prime p,c) (cart (u.scent p c) [] (u.fill u.child p),c) := by |
| let hz:=u.prepared ht he hx |
| apply ReflTransGen.tail hz |
| have hv:=u.pointing ht he (i:=u.H) le_rfl |
| have hs:=u.coal ht hk (u.dawn ht hk) hk.littleR he.hair |
| have heF:u.b.loom u.x0 (u.q,tell p u.H (u.chainR p c u.H),0)= Bow.purec (cart (u.scent p c) [] (u.fill u.child p)+1):=by |
| rw [u.Ax]; simp [Aq,Bow.air,H] |
| rfl |
| have hg := ht.steady; have hu:=ht.run.wp |
| change 1 ≤ u.B.w at hu |
| apply u.blink0 ht heF (u.team ht hv hs (by omega) (by omega) (by omega) (by omega)) hx |
|
|
| lemma onion {p c h e w} (ht:u.Tidy)(he:u.Gown p c) |
| (hc:c∈u.s.domain) (hw:w∈u.s.domain) |
| (hk:u.Herd u.child p c h e w): |
| u.Track (prime p,c) (done (u.scent p c),w):= by |
| obtain ⟨ha,hb⟩:=hk.on |
| have hs:=u.dawn ht ha |
| have hh:=u.ladder ht hk hs he.hair |
| apply ReflTransGen.tail ((u.cool ht he ha hc).trans hh) |
| let v:=u.coal ht ha hs (hb.passed 5 (by omega)) he.hair |
| have he:=u.capDone ht he.hair.1 he.hair.2 |
| have hp:=ht.steady; have hr:=ht.run.wp |
| change 1 ≤ u.B.w at hr |
| exact u.blink0 ht (u.popped_only hs ..) |
| (u.team ht v he (by omega) (by omega) (by omega) (by omega)) hw |
| end Quill |
| end ExactDerandomization.Sub |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Sub |
| open Relay Mint Swirl Counter Relation Finset |
|
|
| def helmet (_:Word)(x:Lore Panel) :Bool := decide ((dec x.2.2.1:Card).1=3) |
| lemma helmetK : Kn helmet := ((Kn.unpack (α:=Card)).comp Kn.next.right.left).left.eq (Kn.fix 3) |
| def snag (p: Mill): Rake := ⟨p.bud.showall,gear _ helmetK⟩ |
|
|
| abbrev gem0 (v c:ℕ):Gem := ((v,c),0) |
| lemma priority (p q): prime p≠done q:=by |
| intro h; have e:=congrArg (fun x=>(dec x:Card).1) h; simp [prime,done] at e |
|
|
| namespace Quill |
| noncomputable section |
| variable (u:Quill) |
| abbrev forge (h:u.Tidy) := h.run.tilt |
| def hall (h:u.Tidy) := Bud.arena (u.forge h) |
| lemma marked {h:u.Tidy} {p c} (he:p<u.b.ports.f u.x0 u.q): |
| (snag u.p).p.check (u.hall h) (gem0 (prime p) c)=true ∧ |
| (snag u.p).root (u.hall h) (gem0 (prime p) c)=false := by |
| constructor |
| · change u.b.stripe0 u.x0 (u.q,prime p,0)=true |
| simp [Bow.stripe0,priority,prime,he] |
| rw [Rake.root,snag,gear_at] |
| simp [helmet,prime] |
| lemma capped (h:u.Tidy) (o c:ℕ): |
| (snag u.p).p.check (u.hall h) (gem0 (done o) c)=true ∧ |
| (snag u.p).root (u.hall h) (gem0 (done o) c)=true:=by |
| constructor |
| · change u.b.stripe0 u.x0 (u.q,done o,0)=true; simp [Bow.stripe0,done] |
| rw [Rake.root,snag,gear_at]; simp [helmet,done] |
| lemma casing (h:u.Tidy){v: Gem}(he:(snag u.p).p.check (u.hall h) v=true): |
| (∃ o c,v=gem0 (done o) c) ∨ ∃ p c,v=gem0 (prime p) c ∧ p<u.b.ports.f u.x0 u.q:=by |
| rcases v with ⟨⟨v,c⟩,j⟩ |
| let o:=(dec v:Card).2.1 |
| change (if j=0 then if v=done o then true else if v=prime o then decide (o < u.b.ports.f u.x0 u.q) |
| else false else false)=true at he |
| split at he |
| · next hw=> |
| split at he |
| · next hh=> exact Or.inl ⟨o,c,by unfold gem0; rw [hh,hw]⟩ |
| split at he |
| · next hh=> exact Or.inr ⟨o,c,by unfold gem0; rw [hh,hw],of_decide_eq_true he⟩ |
| contradiction |
| contradiction |
|
|
| abbrev upG (u:Quill)(h:u.Tidy):= (u.hall h).trees |
| lemma up_act (h:u.Tidy) {a b} : (u.upG h).up a=some b ↔ u.Cr a b := |
| (u.forge h).twig.atU |
| lemma blocked {h:u.Tidy} {a} (he:u.p.mate u.s a) : (u.upG h).up a=none := by |
| cases hz:(u.upG h).up a with |
| | none=> rfl |
| | some b=> exact False.elim (he b ((u.up_act h).1 hz)) |
|
|
| lemma domain_ok {h:u.Tidy} {x:Dot} (hh:x∈(u.upG h).V):x.2∈u.s.domain := |
| ((Bud.walled _).1 hh).2 |
| lemma root_ok {h:u.Tidy}{o c} (ho:u.Stringent o)(hc:c∈u.s.domain): |
| (done o,c)∈(u.upG h).V:= by |
| apply (Bud.walled _).2 |
| exact ⟨u.p.mem_of u.s h.reserve (u.prepaid h (u.capDone h ho.1 ho.2) (by omega)),hc⟩ |
|
|
| def Budded (h:u.Tidy) (r v:Dot): Prop:= ∃ n,(u.upG h).Flight r n v |
| lemma together (h:u.Tidy){r a b} (hr:(u.upG h).up r=none) (ha:u.Track a b): |
| u.Budded h r a ↔ u.Budded h r b:= by |
| induction ha with |
| | refl=>rfl |
| | @tail a b hx e ih=> |
| rw [ih] |
| have he:= (u.up_act h).2 e |
| constructor |
| · rintro ⟨n,hn⟩ |
| cases hn with |
| | node=> grind |
| | above h hz hh=> rw [he] at hz; obtain rfl := Option.some.inj hz; exact ⟨_,hh⟩ |
| rintro ⟨n,hb⟩ |
| exact ⟨_,.above ((u.forge h).twig.pairs e).1 he hb⟩ |
| lemma unite {h:u.Tidy}{r v:Dot}(he:u.Budded h r v)(hp:(u.upG h).up v=none):v=r:=by |
| obtain ⟨n,hn⟩:=he |
| cases hn <;> grind |
|
|
| lemma to_entry {h:u.Tidy}{o c a p s} (ho:u.Stringent o)(hc:c∈u.s.domain)(ha:a∈u.s.domain) |
| (he:u.Lane u.child p a s)(hr:u.Gown p a): |
| u.Budded h (done o,c) (prime p,a) ↔ s=some c ∧ o=u.scent p a:= by |
| have hu:(u.upG h).up (done o,c)=none:=u.blocked (u.shut) |
| cases he with |
| | dry hx hk hw=> |
| rw [u.together h hu (u.cool h hr hx ha)] |
| refine ⟨fun h0=>?_,by simp⟩ |
| have hv:=u.first0 h hx (u.dawn h hx) hr.hair hw |
| have h1:=u.unite h0 (u.blocked hv) |
| have h2:=congrArg Prod.fst h1 |
| exact False.elim (different h2) |
| | born hw=> |
| rename_i i j b |
| have he:b∈u.s.domain:=by |
| cases hw with |
| | solo hr _=> exact hr.hw |
| | pair hr _ _ _ _=> exact hr.hw |
| rw [u.together h hu (u.onion h hr ha he hw)] |
| constructor |
| · intro hv |
| have h1:=u.unite hv (u.blocked u.shut) |
| have hg : done (u.scent p a)=done o:=congrArg Prod.fst h1 |
| have hg2:=congrArg (fun x=>(dec x:Card).2.1) hg |
| simp only [done,decname] at hg2 |
| exact ⟨congrArg some (congrArg Prod.snd h1),hg2.symm⟩ |
| rintro ⟨e,h1⟩; obtain rfl:=Option.some.inj e; rw [← h1] |
| exact ⟨0,.node (u.root_ok ho hc)⟩ |
|
|
| def ent (f:ℕ→ℕ→Option ℕ)(o c:ℕ)(y:Gem) := |
| ∃ a∈u.s.domain,∃ i < u.b.ports.f u.x0 u.q, |
| y=gem0 (prime i) a ∧ f a i=some c ∧ o=u.scent i a |
| structure Suite (f:ℕ→ℕ→Option ℕ) : Prop where |
| row : ∀ a∈u.s.domain,∀ i < u.b.ports.f u.x0 u.q, |
| u.Lane u.child i a (f a i) ∧ u.Gown i a |
|
|
| lemma arrival {h:u.Tidy} {o c f y} (hs:u.Suite f)(ho:u.Stringent o)(hc:c∈u.s.domain): |
| u.ent f o c y ↔ |
| (u.upG h).nest (done o,c) y ∧ |
| (snag u.p).p.check (u.hall h) y=true ∧ y ≠ gem0 (done o) c:= by |
| constructor |
| · rintro ⟨a,ha,i,hi,rfl,e,hx⟩ |
| obtain ⟨hl,hw⟩:= hs.row a ha i hi |
| obtain ⟨n,hk⟩:= (u.to_entry ho hc ha hl hw).2 ⟨e,hx⟩ |
| exact ⟨⟨⟨hk.on,Nat.zero_le _⟩,_,hk⟩,(u.marked hi).1,fun e=>priority i o |
| (congrArg (fun x=>x.1.1) e)⟩ |
| rintro ⟨hv,hx,hz⟩ |
| rcases u.casing h hx with ⟨v,w,rfl⟩ | ⟨p,a,rfl,hp⟩ |
| · exact False.elim (hz (congrArg (fun x:Dot=>(x,0)) (u.unite hv.2 (u.blocked u.shut)))) |
| have he:a∈u.s.domain:=u.domain_ok hv.1.1 |
| obtain ⟨hr,ht⟩:=hs.row a he p hp |
| exact ⟨a,he,p,hp,rfl,(u.to_entry ho hc he hr ht).1 hv.2⟩ |
|
|
| structure Wheel (h:u.Tidy)(f:ℕ→ℕ→Option ℕ)(o c:ℕ)(l:List Gem): Prop where |
| front : Stripe (Flare ((u.upG h).march true) ((snag u.p).p.check (u.hall h))) |
| (gem0 (done o) c) l (gem0 (done o) c) |
| aft : Stripe (Flare ((u.upG h).march false) ((snag u.p).p.check (u.hall h))) |
| (gem0 (done o) c) l.reverse (gem0 (done o) c) |
| unique : l.Nodup |
| members : ∀ y,y∈l↔u.ent f o c y |
|
|
| lemma beat (h:u.Tidy){f o c}(hp:u.Suite f)(ho:u.Stringent o)(hc:c∈u.s.domain) : |
| ∃ l,u.Wheel h f o c l:= by |
| obtain ⟨l,hl,hz,h1,h2⟩:= (u.upG h).streak (u.root_ok ho hc) (u.blocked u.shut) |
| ((snag u.p).p.check (u.hall h)) (u.capped h o c).1 |
| refine ⟨l,h1,h2,(List.nodup_cons.1 hl).2,fun y=>?_⟩ |
| rw [u.arrival (h:=h) hp ho hc] |
| have hg:= (List.nodup_cons.1 hl).1 |
| have hh:=hz y |
| unfold gem0 |
| rw [List.mem_cons] at hh |
| grind |
|
|
| lemma drum {h:u.Tidy}{f o c l}(hv:u.Wheel h f o c l): |
| (snag u.p).Circuit (u.hall h) (gem0 (done o) c) l:= by |
| have hg : (snag u.p).p.Covers (u.hall h):=(u.forge h).yields |
| refine ⟨(hv.front.twain hv.aft).every (fun a b ⟨e,g⟩=>⟨hg.flash _ e,hg.flash _ g⟩), |
| (u.capped h o c).2,?_⟩ |
| intro v hx |
| obtain ⟨a,_,p,ht,rfl,_,_⟩:= (hv.members v).1 hx |
| exact (u.marked ht).2 |
|
|
| / |
| def gloved (w:ℕ→ℕ) : Quill:={u with s:={u.s with hand:=w}} |
|
|
| lemma past {h:u.Tidy} {f o c l} (hs:u.Wheel h f o c l) |
| {w} (h1:(u.gloved w).Tidy): |
| (u.gloved w).Wheel h1 f o c l:=by |
| rcases hs with ⟨ha,hb,hc,hd⟩ |
|
|
| exact ⟨ha,hb,hc,hd⟩ |
|
|
| end |
| end Quill |
| end ExactDerandomization.Sub |
|
|
| end |
|
|
| end OAI |
|
|
