| import OAI.Computability.Logspace.CompressionBounds |
| import OAI.Computability.Logspace.QueryPrograms |
|
|
| namespace OAI |
|
|
| /-! |
| Programs implementing sparse endpoint pools and row compression. |
|
|
| From OpenAI, *Exact Derandomization of Logarithmic Space: L = RL = BPL*. |
| -/ |
|
|
| set_option autoImplicit true |
|
|
| section |
|
|
| namespace ExactDerandomization.Reed |
| noncomputable section |
| open Buf Analysis Hie At Finset |
|
|
| /-! A single update view of a pool of endpoints. |
| Old slots are expressed as (their two coordinates minus the current |
| baseline). Identity of a slot includes its walk code, implemented but |
| not exposed to the real arithmetic except as a bit. -/ |
| structure Poolx where |
| p:Buf.Params |
| raw:Blob |
| m:ℕ |
| tag:ℕ→ℕ |
| place:ℕ→ℕ |
| chip:ℕ→ Pt |
|
|
| namespace Poolx |
| variable (v:Poolx) |
| abbrev P:=range v.m |
| abbrev valid (i:ℕ):Prop:=v.tag i≠0 |
| abbrev joins(i y:ℕ):Prop:=v.valid i∧v.place i=y |
| abbrev pals(i j:ℕ):Prop:=v.valid i∧ v.joins j (v.place i) |
| abbrev mayor (i:ℕ):Prop:=v.valid i ∧ ∀ j∈range i,¬v.pals i j |
| abbrev b:=v.raw.base |
| abbrev S:=v.p.S |
| def grainp (i j:ℕ): Pt:=if v.pals i j then v.chip j else 0 |
| def meal (i:ℕ): Pt:= line v.b + ∑ j∈v.P,v.grainp i j |
|
|
| structure Nice (v:Poolx):Prop where |
| baseM : 0 ≤ v.b ∧ v.b ≤ 4 |
| atS : ∀ i∈v.P,v.valid i→v.place i∈v.S |
| plan : ∀ y∈v.S, v.raw.ts y=line v.b + ∑ j∈v.P,if v.joins j y then v.chip j else 0 |
|
|
| namespace Nice |
| variable {v:Poolx}(h:Nice v) |
| include h |
| lemma serves {i:ℕ}(hi:i∈v.P)(he:v.valid i): v.meal i=v.raw.ts (v.place i):=by |
| unfold meal; rw [h.plan _ (h.atS i hi he)]; unfold grainp pals; dsimp [valid] at *; simp [he] |
| lemma deserted {y:ℕ}(he:y∈v.S) (hg:∀ i∈v.P,¬v.mayor i ∨ v.place i≠y): |
| v.raw.ts y=line v.b := by |
| have hh(j)(hj:j∈v.P): ¬ v.joins j y:=by |
| intro ht |
| let s:= v.P.filter fun i=> v.joins i y |
| have hc:s.Nonempty:=⟨j,mem_filter.2 ⟨hj,ht⟩⟩ |
| let i:=s.min' hc |
| have hf:i∈s:=min'_mem ..; obtain ⟨h1,h2,h3⟩:=mem_filter.1 hf |
| have hw:= (hg i h1).resolve_right (by simp only [h3]; simp) |
| apply hw |
| refine ⟨h2,fun l hl hu=>?_⟩ |
| have hx:= mem_range.1 hl |
| have hv:l∈s:=mem_filter.2 ⟨mem_range.2 (hx.trans (mem_range.1 h1)),⟨hu.2.1,hu.2.2.trans h3⟩⟩ |
| exact not_lt_of_ge (min'_le _ _ hv) hx |
| rw [h.plan y he] |
| rw [sum_eq_zero] |
| · simp |
| intro j hj; rw [ite_eq_right (hh j hj)] |
| |
| omit h in |
| lemma unique {i j:ℕ} (hi:v.mayor i)(hj:v.mayor j)(he:v.place i=v.place j):i=j:=by |
| rcases lt_trichotomy i j with hs|hs|hs |
| · exact False.elim (hj.2 i (mem_range.2 hs) ⟨hj.1,hi.1,he⟩) |
| · exact hs |
| exact False.elim (hi.2 j (mem_range.2 hs) ⟨hi.1,hj.1,he.symm⟩) |
| lemma citizens {i:ℕ} (he:i∈v.S)(hi:v.raw.ts i≠line v.b):∃ j∈v.P,v.mayor j∧v.place j=i:= by |
| by_contra! hh |
| apply hi (h.deserted he (fun j hj=> or_iff_not_imp_left.mpr (by by_contra hc; grind))) |
| |
| def listP (v:Poolx)(f:Pt→ℝ)(i:ℕ):ℝ:= if v.mayor i then f (v.meal i) else 0 |
| |
| lemma sampled (f:Pt→ℝ)(hf:f (line v.b)=v.b){x:ℝ}(hp:v.b ≤ x): |
| (v.P.filter (fun i=>x<listP v f i)).card = (v.S.filter (fun j=>x< f (v.raw.ts j))).card:=by |
| let P:=v.P.filter (fun i=> x<listP v f i) |
| let S:=v.S.filter (fun j=> x<f (v.raw.ts j)) |
| have h0(i)(hi:i∈P): v.mayor i ∧ v.meal i=v.raw.ts (v.place i) := by |
| obtain ⟨hx,he⟩:=mem_filter.1 hi |
| unfold listP at he |
| split at he |
| · next hg=> exact ⟨hg,h.serves hx hg.1⟩ |
| have hl:=h.baseM.1; linarith |
| have hl:P.image v.place=S:= by |
| ext j; constructor |
| · intro hx; obtain ⟨i,he,rfl⟩:=mem_image.1 hx |
| obtain ⟨ha,hb⟩:=h0 i he; obtain ⟨he,hf'⟩:=mem_filter.1 he |
| refine mem_filter.2 ⟨h.atS _ he ha.1,?_⟩ |
| unfold listP at hf'; rw [ite_eq_left ha,hb] at hf'; exact hf' |
| intro he; obtain ⟨he,hg⟩:=mem_filter.1 he |
| have hv:v.raw.ts j≠line v.b:=by intro hw; rw [hw,hf] at hg; linarith |
| obtain ⟨i,hi,hA,hB⟩:=h.citizens he hv |
| apply mem_image.2; refine ⟨i,mem_filter.2 ⟨hi,?_⟩,hB⟩ |
| unfold listP; rw [ite_eq_left hA,h.serves hi hA.1,hB]; exact hg |
| change P.card=S.card |
| rw [← hl]; symm; apply card_image_iff.mpr |
| intro i hi j hj h1 |
| exact (unique (v := v)) (h0 i hi).1 (h0 j hj).1 h1 |
| |
| lemma staged (f:Pt→ℝ)(hf:f (line v.b)=v.b)(k): |
| max v.b (rank v.P (listP v f) k)=max v.b (rank v.S (fun j=> f (v.raw.ts j)) k):=by |
| have h0{x:ℝ}(hx:v.b ≤ x): (x<rank v.P (listP v f) k) ↔ (x<rank v.S (fun j=>f (v.raw.ts j)) k):=by |
| have ht:=h.baseM.1.trans hx |
| rw [rank_gt ht,rank_gt ht,h.sampled f hf hx] |
| let a:=rank v.P (listP v f) k; let b:=rank v.S (fun j=>f (v.raw.ts j)) k |
| have hh{x}: (x < max v.b a) ↔ (x < max v.b b):=by |
| by_cases hv:x<v.b |
| · simp [lt_max_iff,hv] |
| rw [lt_max_iff,lt_max_iff]; exact or_congr Iff.rfl (h0 (le_of_not_gt hv)) |
| change max v.b a= max v.b b |
| rcases lt_trichotomy (max v.b a) (max v.b b) with he|he|he |
| · exact False.elim (lt_irrefl _ (hh.mpr he)) |
| · exact he |
| exact False.elim (lt_irrefl _ (hh.1 he)) |
| lemma higherEnd : |
| v.p.U v.raw = min 4 (max v.p.rho (max v.b (rank v.P (listP v ht) v.p.n))):=by |
| rw [h.staged ht (ht_line h.baseM.1)]; rfl |
| lemma middleEnd: |
| v.raw.rk v.S v.p.K=max v.b (rank v.P (listP v Prod.fst) v.p.K):=by |
| rw [h.staged Prod.fst rfl]; unfold Blob.rk; rw [max_comm] |
| |
| abbrev U (v:Poolx):=v.p.U v.raw |
| abbrev Z (v:Poolx):=v.p.Z v.raw |
| lemma whole {B:Finset ℕ} (hp:B⊆v.P)(hb:U v <4) |
| (he:∀ i∈B,v.mayor i ∧ U v< ht (v.meal i)): B.card ≤ v.p.n:=by |
| have hz: (B.image v.place).card=B.card:=card_image_iff.2 fun i hi j hj hx=> |
| (unique (v := v)) (he i hi).1 (he j hj).1 hx |
| rw [← hz] |
| apply Params.enough v.p hb |
| · intro j hj |
| obtain ⟨i,h1,rfl⟩:=mem_image.1 hj |
| exact h.atS _ (hp h1) (he _ h1).1.1 |
| intro j hj; obtain ⟨i,he1,rfl⟩:=mem_image.1 hj |
| obtain ⟨ht,hv⟩:=he i he1; rw [← h.serves (hp he1) ht.1]; exact hv |
| |
| lemma coverHome {B:Finset ℕ}(he:∀ i∈v.P,v.mayor i → 2*U v<ht (v.meal i) → i∈ B) |
| (R:ℝ)(hr:4 ≤ R){j:ℕ}(hj:j∈v.S)(ht:j∉B.image v.place): |
| (struck R (v.p.push v.raw)).ts j=line (Z v):=by |
| apply v.p.listed R hr _ hj ht |
| intro i hi hz |
| have hh:v.raw.ts i ≠ line v.b:=by |
| intro hg; rw [hg,ht_line h.baseM.1] at hz |
| have ha:=v.p.U_old (v:=v.raw) h.baseM.2; have hp:=v.p.U_nn v.raw |
| change _ ≤ _ at ha; linarith |
| obtain ⟨k,hk,hA,hB⟩:=h.citizens hi hh |
| have hh:k∈B:=he k hk hA (by rw [h.serves hk hA.1,hB]; exact hz) |
| exact mem_image.2 ⟨k,hh,hB⟩ |
| end Nice |
| end Poolx |
| end |
| end ExactDerandomization.Reed |
| |
| end |
| |
| section |
| |
| namespace ExactDerandomization.Reed |
| open Counter Relay Rill Fret Buf Analysis Hie At Finset Seats |
| open Poolx |
| abbrev Stool:=ℕ × ℕ× ℕ |
| def film (s:Seats)(i j:ℕ):Seats:= s.panelx (enc ((s.info,i,j):Stool)) |
| abbrev V (_:Word)(i:ℕ):Stool:=dec i |
| lemma VK:Kn V:=Kn.unpack |
| |
| def rootsD (k:Cub ℕ ℕ): Cub ℕ ℕ:= |
| ⟨fun x a=> k.f x (V x a).1,k.runs.comp VK.left⟩ |
| def leftQ :Cub ℕ ℕ:=⟨fun x a=>(V x a).2.1,VK.right.left⟩ |
| def stairs (rise:Bool)(x:Word)(a:History):ℕ:= |
| let b:=V x a.1 |
| enc (if rise then ((b.1,a.2,0):Stool) else (b.1,b.2.1,a.2)) |
| lemma stairK (b):Kn (stairs b):=by |
| have h:=VK.comp (Kn.first (β:=ℕ)) |
| cases b |
| · exact Kn.wash.comp (h.left.tuple (h.right.left.tuple Kn.next)) |
| exact Kn.wash.comp (h.left.tuple (Kn.next.tuple (Kn.fix _))) |
| def centra (x:Word)(i:ℕ):ℕ:= enc (((V x i).1,0,0):Stool) |
| lemma centerK:Kn centra:=Kn.wash.comp (VK.left.tuple (Kn.fix _)) |
| def campk (p:Knob):Knob:=⟨rootsD p.height,rootsD p.bank,rootsD p.store⟩ |
| lemma spread {s:Seats}{p} (h:s.stable p)(i j):(film s i j).stable (campk p):=by |
| intro x hx; have he:=h x hx |
| refine ⟨he.1,?_,?_⟩ |
| · change p.height.f _ (dec (enc ((s.info,i,j):Stool)):Stool).1=_ |
| rw [dec_round]; exact he.2.1 |
| change p.bank.f _ (dec (enc ((s.info,i,j):Stool)):Stool).1=_ |
| rw [dec_round]; exact he.2.2 |
| lemma spanFilm {s:Seats}{p H}(h:Live s.head p H)(i j): Live (film s i j).head (campk p) H:=by |
| change (2:ℕ)^H ≤ p.store.f _ (dec (enc ((s.info,i,j):Stool)):Stool).1 |
| rw [dec_round]; exact h |
| |
| def sideq (p:Pt)(b:Bool) := if b then p.1 else p.2 |
| structure Board where |
| n: Cub ℕ ℕ |
| kth: Bool→Cub ℕ ℕ |
| I:Knob |
| equal0: Cog |
| pigment: Cog |
| baseC:Cog |
| reserveC:Cog |
| pot:Bool → Cog |
| inp:ℕ |
| lid:ℕ |
| lips:ℕ |
| cup:ℕ |
| |
| namespace Board |
| noncomputable section |
| variable (p:Board) |
| def bridgeQ (b:Bool)(k:Cub ℕ ℕ):Branch:=⟨rootsD p.n,⟨_,stairK b⟩,k,p.cup⟩ |
| lemma backBE (s:Seats) (b:Bool) i j k a: |
| (film s i j).bench (p.bridgeQ b k) a=if b then film s a 0 else film s i a:=by |
| cases b <;> simp [film,bench,Branch.port,stairs,panelx,bridgeQ] |
| |
| @[simp] lemma numbers (s:Seats) (c:Cub ℕ ℕ) (i j): (rootsD c).f s.l.x (film s i j).info=c.f s.l.x s.info:=by |
| simp [rootsD,film,info,panelx] |
| @[simp] lemma centeral (s:Seats) (i j) : centra s.l.x (film s i j).info=(film s 0 0).info:=by |
| simp [centra,film,info,panelx] |
| |
| abbrev R (p:Board)(s:Seats):=massB p.lid s.d |
| def gcat (v:Poolx)(i j:ℕ):ℕ:=if v.pals i j then 1 else 0 |
| |
| abbrev address (v:Poolx)(i:ℕ):Prop:=i=0∨i<v.m |
| /-- Supply over all seats and a common work horizon. Carry lip & reservoir budget abstract. -/ |
| structure Holds (s:Seats)(c T:ℕ)(v:Poolx):Prop where |
| pri : 4 ≤ c |
| ball: v.Nice |
| good: s.stable p.I |
| horizon:Live s.head p.I T |
| N : p.n.f s.l.x s.info=v.m |
| cap : (p.kth true).f s.l.x s.info=v.p.K |
| carry:(p.kth false).f s.l.x s.info=v.p.n |
| volume : v.m<2^(p.cup*s.d) |
| coverM:Punct s.head c v.m |
| clampR: 4 ≤ p.R s |
| costrho:(massB p.lips s.d)⁻¹ ≤ v.p.rho ∧ v.p.rho ≤ 1 |
| baseU :∀ i,address v i→ (film s i 0).band c T p.inp p.baseC v.raw.base |
| rhoQ :∀ i,address v i→ (film s i 0).band c T p.inp p.reserveC v.p.rho |
| tagM :∀ i < v.m, (film s i 0).rite c p.pigment (v.tag i)∧ Punct s.head c (v.tag i) |
| both :∀ i < v.m,∀ j < v.m, (film s i j).rite c p.equal0 (gcat v i j) |
| glow :∀ i < v.m,∀ j < v.m,v.pals i j → ∀ b,(film s i j).band c T p.inp (p.pot b) (sideq (v.chip j) b) |
| |
| def pollStack:Branch:={p.bridgeQ false ⟨_,Kn.fix 0⟩ with n:=leftQ} |
| def detective:Seek:= ⟨p.pollStack,p.equal0⟩ |
| def offer:Cog:=Cargo.choose p.detective.latch p.pigment Seats.nothingX |
| |
| abbrev postC(c:ℕ):=16*(16*c) |
| def solar(v:Poolx)(i:ℕ):ℕ:= if v.mayor i then v.tag i else 0 |
| lemma nowEQ(v:Poolx)(i:ℕ):solar v i≠0 ↔ v.mayor i:=by |
| unfold solar; split |
| · next h=>exact iff_of_true h.1 h |
| next h=>simp [h] |
| |
| namespace Holds |
| variable {s:Seats}{p c T v}(h:Holds p s c T v) |
| include h |
| lemma hpos : 1 ≤ s.d:=(stable_home h.good).1.1 |
| lemma act (i j):hasOK (film s i j):=rocks (spread h.good i j) |
| lemma lenpoll (i j) k b : (film s i j).freq (p.bridgeQ b k)=v.P:=by |
| change range ((rootsD _).f s.l.x (film s i j).info)=_ |
| rw [numbers,h.N] |
| lemma book {i:ℕ}(he:i<v.m): |
| (film s i 0).rite (postC c) p.offer (solar v i):=by |
| let f:=film s i 0 |
| let q:=p.detective |
| have hm:q.N f=i:=by simp [q,Seek.N, detective,pollStack,f,film,leftQ,info,panelx] |
| have hz:=h.act i 0; have hx:=h.pri |
| have hp:=q.earns hz (by omega:2 ≤ c) (gcat v i) (by |
| rw [hm]; unfold Punct; exact le_trans (Nat.add_le_add_right (lb_mono he.le) _) h.coverM) (show ∀ j<q.N f, |
| _ from fun j hj=>by |
| rw [hm] at hj |
| constructor |
| · unfold gcat |
| split |
| · unfold Punct; rw [lb_one]; change 1+1 ≤ c*s.d; have he:=h.hpos; nlinarith |
| exact punct0 (has_home hz) (by omega) |
| have hg : f.bench q.b j=film s i j:=by simp [bench,f,q,detective,pollStack,film,panelx,bridgeQ,Branch.port,stairs] |
| rw [hg]; exact h.both i he j (hj.trans he)) |
| dsimp only at hp |
| change Punct f.head (4*c) (Seek.relief (gcat v i) 0 (q.N f)).2 ∧ _ at hp |
| let r:= (Seek.relief (gcat v i) 0 i).2 |
| rw [hm] at hp |
| have hh : r=0 ↔ ∀ j∈range i,¬v.pals i j:=by |
| rw [show (r=0) ↔ _ from Seek.missed]; unfold Seek.part gcat |
| constructor |
| · intro hg j hj ht |
| have hq:0<((range i).filter (fun j=> (if v.pals i j then 1 else (0:ℕ))≠0)).card:= |
| card_pos.mpr ⟨j,mem_filter.2 ⟨hj,by rw [ite_eq_left ht]; omega⟩⟩ |
| omega |
| intro hg |
| rw [le_zero_iff,card_eq_zero] |
| ext j |
| simp only [mem_filter,notMem_empty,iff_false] |
| rintro ⟨hj,hq⟩; rw [ite_eq_right (hg _ hj)] at hq; contradiction |
| apply Seats.steer hp.2 |
| · intro hl; have hA:=hh.1 hl |
| have hu :solar v i=v.tag i:=by unfold solar; split <;> grind |
| rw [hu]; exact higher (h.tagM i he).1 (by omega) (by omega) |
| intro hl |
| have hu:solar v i=0:=ite_eq_right (fun hv=> hl (hh.2 hv.2)) |
| rw [hu]; exact Seats.blankD hz (by omega) |
| |
| end Holds |
| end |
| end Board |
| end ExactDerandomization.Reed |
| |
| end |
| |
| section |
| |
| namespace ExactDerandomization.Reed |
| open Counter Relay Rill Fret Buf Analysis Hie At Finset Seats Poolx Board |
| open Fret.Lyric |
| |
| namespace Lu |
| def son (n i:ℕ):Lyric:=.solo i ⟨_,Kn.fix (Coin.ofZ n)⟩ |
| abbrev psum:= bi .plus |
| abbrev diff:= bi .minus |
| abbrev times:=bi .prod |
| abbrev sup:=bi .greater |
| abbrev inf:=bi .lesser |
| abbrev zeroE:=son 0 0 |
| def kohn(n:ℕ):Lyric:=son n n |
| abbrev absE (x:Lyric):=Lu.sup x (diff zeroE x) |
| abbrev clippy (R x:Lyric):=Lu.inf R (Lu.sup (diff zeroE R) x) |
| abbrev reset (x:Lyric)(w:ℕ):= Lyric.duet .plus x zeroE w |
| noncomputable section |
| structure Standard (s:Seats)(p:Knob)(T:ℕ): Prop where |
| st : stable s p |
| he : Live s.head p T |
| namespace Standard |
| variable {s p T}(h:Standard s p T) |
| include h |
| lemma shins(c i n:ℕ) (he:(n:ℝ) ≤ massB i s.d) : Chor p c T s (son n i) (n:ℝ):=by |
| have hp : (Coin.ofZ n).v=(n:ℝ):=by simp |
| rw [← hp]; apply Chor.played h.st h.he (fun x _=> rfl) |
| rw [hp,abs_of_nonneg (by positivity)]; exact he |
| lemma rove (c n):Chor p c T s (kohn n) (n:ℝ):=h.shins c n n (swellB (stable_home h.st).1.1).le |
| lemma sil {c}: Chor p c T s zeroE 0:=by |
| convert h.shins c 0 0 (by simp [massB]) using 1; norm_num |
| variable {c f g x y} |
| lemma up0 (he:Chor p c T s f x) (hg:Chor p c T s g y):Chor p c T s (Lu.sup f g) (max x y):= |
| he.minuet hg h.st .greater |
| lemma lo0 (he:Chor p c T s f x) (hg:Chor p c T s g y):Chor p c T s (Lu.inf f g) (min x y):= |
| he.minuet hg h.st .lesser |
| lemma additions (he:Chor p c T s f x) (hg:Chor p c T s g y): Chor p c T s (psum f g) (x+y):= |
| he.minuet hg h.st .plus |
| lemma dubs (he:Chor p c T s f x) (hg:Chor p c T s g y): Chor p c T s (diff f g) (x-y):= |
| he.minuet hg h.st .minus |
| lemma mult0 (he:Chor p c T s f x) (hg:Chor p c T s g y): Chor p c T s (times f g) (x*y):= |
| he.minuet hg h.st .prod |
| lemma neg0 (he:Chor p c T s f x) : Chor p c T s (diff zeroE f) (-x):=by |
| simpa using h.dubs h.sil he |
| lemma absti (he:Chor p c T s f x): Chor p c T s (absE f) |x|:= by |
| have hp: |x|=max x (-x):=by exact abs_eq_max_neg |
| rw [hp]; exact h.up0 he (h.neg0 he) |
| lemma clips (he:Chor p c T s f x)(hg:Chor p c T s g y): Chor p c T s (clippy f g) (sat x y):= |
| h.lo0 he (h.up0 (h.neg0 he) hg) |
| lemma ring0 (he:Chor p c T s f x)(w)(hb:|x| ≤ massB w s.d):Chor p c T s (reset f w) x:=by |
| have ht:Doop.val .plus x 0=x:=add_zero _ |
| have hu:|Doop.val .plus x 0| ≤ massB w s.d:=by rw [ht]; exact hb |
| convert Chor.doo h.st he h.sil hu using 1; exact ht.symm |
| end Standard |
| end |
| end Lu |
| |
| namespace Board |
| noncomputable section |
| open Lu |
| variable (p:Board) |
| |
| def music (q:Cog):Cog:=Cargo.choose q |
| (Brick.solo (campk p.I) ⟨_,Kn.fix (Coin.ofZ 0)⟩ 0) |
| (Brick.solo (campk p.I) ⟨_,Kn.fix (Coin.ofZ 1)⟩ 0) |
| def warmth (p:Board):Lyric:= .use 0 (p.music p.offer) |
| def pit0 (p:Board):Cog:= Brick.solo (campk p.I) ⟨_,Kn.fix (Coin.ofZ 0)⟩ p.inp |
| def pit (p:Board)(b:Bool): Cog:= Cargo.choose p.equal0 p.pit0 (p.pot b) |
| abbrev goalCost (c:ℕ):=postC c+200 |
| namespace Holds |
| variable {s:Seats}{p c T v}(h:Holds p s c T v) |
| include h |
| abbrev Cext (p:Board)(s:Seats)(c T i j:ℕ):= Chor (campk p.I) (goalCost c) T (film s i j) |
| lemma stifle (i j):Standard (film s i j) (campk p.I) T:= |
| ⟨spread h.good i j,spanFilm h.horizon i j⟩ |
| lemma currency : 1 ≤ c ∧ c ≤ goalCost c ∧ 1 ≤ goalCost c:=by have:=h.pri; unfold goalCost postC; omega |
| lemma chorus {i}(he:i<v.m): Cext p s c T i 0 (p.warmth) (if v.mayor i then 1 else 0):=by |
| let f:=film s i 0 |
| let b:=goalCost c |
| have hp:=h.stifle i 0; have hq:=h.pri |
| have hz:f.rite b p.offer (solar v i):=higher (h.book he) (by unfold postC; omega) (by unfold b goalCost; omega) |
| apply Chor.byear |
| apply Seats.avis hz |
| · intro hl |
| rw [ite_eq_right (show ¬v.mayor i by intro e; exact ((nowEQ v i).2 e) hl)] |
| have ht:=sing hp.sil (h.currency.2.2) (H:=T) (by simp [tail,zeroE,son]) |
| exact flex ht (by change 1 ≤ powder 100; unfold powder; omega) |
| (by change powder 100 ≤ goalCost c; unfold goalCost powder; omega) le_rfl |
| intro hl |
| rw [ite_eq_left ((nowEQ v i).1 hl)] |
| have hh:Cext p s c T i 0 (son 1 0) 1:=by |
| convert hp.shins b 0 1 (by simp [massB]) using 1; norm_num |
| exact flex (sing hh (h.currency.2.2) (H:=T) (by simp [son,tail])) (by change 1 ≤ powder 100; unfold powder; omega) |
| (by change powder 100 ≤ goalCost c; unfold goalCost powder; omega) le_rfl |
| |
| lemma slices {i j:ℕ}(hi:i<v.m)(hj:j<v.m)(b:Bool): |
| Cext p s c T i j (.use p.inp (p.pit b)) (sideq (v.grainp i j) b):=by |
| have hp:=h.stifle i j; have he:=h.currency |
| apply Chor.byear |
| apply Seats.avis (higher (h.both i hi j hj) he.1 he.2.1) |
| · intro hl |
| have hh :¬ v.pals i j:=by intro x; unfold gcat at hl; rw [ite_eq_left x] at hl; omega |
| have ht:Cext p s c T i j (son 0 p.inp) 0:=by |
| convert hp.shins (goalCost c) p.inp 0 (by simp) using 1; norm_num |
| unfold Poolx.grainp; rw [ite_eq_right hh] |
| have hh2:sideq 0 b=0:=by cases b <;> rfl |
| rw [hh2] |
| exact flex (sing ht (h.currency.2.2) (H:=T) (by simp [tail,son])) (by change 1 ≤ powder 100; unfold powder; omega) |
| (by change powder 100 ≤ goalCost c; unfold goalCost powder; omega) le_rfl |
| intro hh |
| have hz:v.pals i j:=by by_contra hc; unfold gcat at hh; rw [ite_eq_right hc] at hh; contradiction |
| unfold Poolx.grainp; rw [ite_eq_left hz] |
| exact flex (h.glow i hi j hj hz b) he.1 he.2.1 le_rfl |
| end Holds |
| |
| end |
| end Board |
| end ExactDerandomization.Reed |
| |
| end |
| |
| section |
| |
| namespace ExactDerandomization.Reed.Board |
| open Counter Relay Rill Fret Buf Analysis Hie At Finset Seats Poolx Poolx.Nice Lu |
| open Fret.Lyric |
| noncomputable section |
| variable (p:Board) |
| |
| def rowB (b:Bool):Lyric:= if b then .use p.inp p.baseC else zeroE |
| def bites (b:Bool):Lyric:=psu b |
| where psu b:= Lu.psum (p.rowB b) |
| (.heap true (p.bridgeQ false ⟨_,Kn.fix 0⟩) (.use p.inp (p.pit b))) |
| abbrev rawP:= p.bites true |
| abbrev sight:= Lu.sup (absE p.rawP) (absE (p.bites false)) |
| abbrev starsR (b:Bool):Lyric:= |
| Lu.sup (p.rowB true) (.heap false (p.bridgeQ true (rootsD (p.kth b))) |
| (Lu.times p.warmth (if b then p.rawP else p.sight))) |
| abbrev riseR :Lyric:= Lu.inf (kohn 4) (Lu.sup (.use p.inp p.reserveC) (p.starsR false)) |
| abbrev zenith :Lyric:= Lu.inf (kohn 4) (Lu.sup p.riseR (Lu.inf (p.starsR true) |
| (Lu.times (kohn 3) p.riseR))) |
| abbrev border (b:Bool):Lyric := if b then p.zenith else zeroE |
| abbrev shore :Lyric := Lu.times (kohn 7) (Lu.sup zeroE (Lu.diff p.sight (Lu.times (kohn 2) p.riseR))) |
| abbrev surf (b:Bool):Lyric:=Lu.psum (p.border b) (clippy p.shore (Lu.diff (p.bites b) (p.border b))) |
| def topE:Lyric:= .solo p.lid ⟨fun x a=> scaleC (campk p.I) p.lid x a.1, |
| (scaleK (campk p.I) p.lid).comp Kn.first⟩ |
| abbrev guardE (b:Bool):Lyric:=reset (clippy p.topE (p.surf b)) p.lid |
| abbrev borderE (b:Bool):Lyric:= reset (p.border b) p.lid |
| abbrev harsh : Lyric:=Lu.diff (Lu.times (kohn 2) p.sight) (Lu.times (kohn 3) p.riseR) |
| |
| namespace Holds |
| variable {s:Seats}{p c T v}(h:Holds p s c T v) |
| include h |
| |
| lemma rowUp {i}(hi:address v i)(b):Cext p s c T i 0 (p.rowB b) (sideq (Buf.line v.b) b):=by |
| cases b |
| · exact (h.stifle i 0).sil |
| exact .byear (flex (h.baseU i hi) h.currency.1 h.currency.2.1 le_rfl) |
| |
| lemma scoopG (i j:ℕ)(b u:Bool)(k:Cub ℕ ℕ)(f:Lyric)(V:ℕ→ℝ) |
| (hp:∀ a∈v.P, |
| Cext p s c T (if b then a else i) (if b then 0 else a) f (V a)): |
| Cext p s c T i j (.heap u (p.bridgeQ b k) f) (if u then ∑ a∈v.P,V a else |
| rank v.P V (k.f s.l.x (film s i j).head.info)):=by |
| let m:=p.bridgeQ b k; let x:=film s i j |
| have hh:x.freq m=v.P:= h.lenpoll i j k b |
| rw [← hh]; apply Chor.little |
| · exact spread h.good i j |
| · change (rootsD _).f s.l.x x.info < 2^(p.cup*s.d) |
| unfold x; rw [numbers]; exact h.N.symm ▸ h.volume |
| intro a ha |
| rw [p.backBE] |
| rw [hh] at ha; cases b <;> exact hp a ha |
| |
| lemma bowlC {i}(he:i<v.m)(b):Cext p s c T i 0 (p.bites b) (sideq (v.meal i) b):=by |
| let m:=p.bridgeQ false ⟨_,Kn.fix 0⟩ |
| have hp:Cext p s c T i 0 (.heap true m (.use p.inp (p.pit b))) |
| (∑ j∈v.P,sideq (v.grainp i j) b):=h.scoopG i 0 false true ⟨_,Kn.fix 0⟩ |
| _ _ fun a ha=> h.slices he (mem_range.1 ha) b |
| have hz:sideq (v.meal i) b=sideq (Buf.line v.b) b+∑ j∈v.P,sideq (v.grainp i j) b:=by |
| cases b <;> simp [Poolx.meal,sideq] <;> first | exact Prod.snd_sum | exact Prod.fst_sum |
| rw [hz]; exact (h.stifle i 0).additions (h.rowUp (Or.inr he) b) hp |
| |
| lemma sky {i} (he:i<v.m): Cext p s c T i 0 p.sight (ht (v.meal i)):= |
| let hp:=h.stifle i 0 |
| hp.up0 (hp.absti (h.bowlC he true)) (hp.absti (h.bowlC he false)) |
| |
| lemma weep {i}(he:i<v.m)(b:Bool): |
| Cext p s c T i 0 (Lu.times p.warmth (if b then p.rawP else p.sight)) |
| (Poolx.Nice.listP v (if b then Prod.fst else ht) i):=by |
| have ht:Cext p s c T i 0 (if b then p.rawP else p.sight) |
| ((if b then (Prod.fst:Pt→ℝ) else Buf.ht) (v.meal i)):=by |
| cases b |
| · exact h.sky he |
| exact h.bowlC he true |
| convert (h.stifle i 0).mult0 (h.chorus he) ht using 1 |
| unfold listP; split <;> simp |
| |
| lemma starship {i}(hi:address v i)(b:Bool): |
| Cext p s c T i 0 (p.starsR b) (max v.b (rank v.S (fun j=> (if b then Prod.fst else ht) (v.raw.ts j)) |
| (if b then v.p.K else v.p.n))):=by |
| let k := if b then v.p.K else v.p.n |
| let G:= if b then (Prod.fst:Pt→ℝ) else ht |
| let f:=film s i 0 |
| let p0:= p.bridgeQ true (rootsD (p.kth b)) |
| have hu:(rootsD (p.kth b)).f s.l.x f.head.info=k:=by |
| change (rootsD (p.kth b)).f s.l.x (film s i 0).info=k |
| rw [numbers]; cases b |
| · exact h.carry |
| exact h.cap |
| have hz:= h.scoopG i 0 true false (rootsD (p.kth b)) |
| _ (Poolx.Nice.listP v G) fun a ha=>h.weep (mem_range.1 ha) b |
| have hr: G (Buf.line v.b)=v.b:=by |
| cases b |
| · exact ht_line h.ball.baseM.1 |
| exact rfl |
| simp only [Bool.false_eq_true,ite_false] at hz |
| rw [hu] at hz |
| rw [← h.ball.staged G hr]; exact (h.stifle i 0).up0 (h.rowUp hi true) hz |
| |
| lemma aurora {i} (hi:address v i): Cext p s c T i 0 p.riseR (U v):=by |
| let z:=goalCost c; let w:=h.stifle i 0 |
| have hh:Cext p s c T i 0 (.use p.inp p.reserveC) v.p.rho:= |
| .byear (flex (h.rhoQ i hi) h.currency.1 h.currency.2.1 le_rfl) |
| have hf:Cext p s c T i 0 (kohn 4) 4:=by exact w.rove z 4 |
| exact w.lo0 hf (w.up0 hh (h.starship hi false)) |
| |
| lemma skyline {i} (hi:address v i):Cext p s c T i 0 p.zenith (Z v):=by |
| let z:=goalCost c; let w:=h.stifle i 0 |
| have hf:Cext p s c T i 0 (kohn 4) 4:=by exact w.rove z 4 |
| have hg:Cext p s c T i 0 (kohn 3) 3:=by exact w.rove z 3 |
| have hu:Cext p s c T i 0 (p.starsR true) (v.raw.rk v.S v.p.K):=by |
| unfold At.Blob.rk; rw [max_comm]; exact h.starship hi true |
| have he:=h.aurora hi |
| exact w.lo0 hf (w.up0 he (w.lo0 hu (w.mult0 hg he))) |
| |
| lemma trench {i} (he:i<v.m): Cext p s c T i 0 p.harsh (2*ht (v.meal i)-3*U v):= |
| let w:=h.stifle i 0; let z:=goalCost c |
| have hz:Cext p s c T i 0 (kohn 2) 2:=by exact w.rove z 2 |
| have hg:Cext p s c T i 0 (kohn 3) 3:=by exact w.rove z 3 |
| w.dubs (w.mult0 hz (h.sky he)) (w.mult0 hg (h.aurora (Or.inr he))) |
| |
| lemma blankx {i}(hi:address v i)(b):Cext p s c T i 0 (p.border b) (sideq (Buf.line (Z v)) b):=by |
| cases b |
| · exact (h.stifle i 0).sil |
| exact h.skyline hi |
| lemma boardU {i}(hi:address v i)(b):Cext p s c T i 0 (p.borderE b) (sideq (Buf.line (Z v)) b):=by |
| apply (h.stifle i 0).ring0 (h.blankx hi b) |
| have ht : 0 ≤ Z v:=v.p.Z_nn v.raw |
| have hz : Z v ≤ 4:=(v.p.Z_w v.raw).2.2 |
| have hp : 4 ≤ p.R s:=h.clampR |
| cases b |
| · change |(0:ℝ)| ≤ p.R s; rw [abs_zero]; linarith |
| change |Z v| ≤ p.R s; rw [abs_of_nonneg ht]; linarith |
| |
| lemma heights(i):Cext p s c T i 0 p.topE (p.R s):=by |
| let f:=film s i 0; let w:=h.stifle i 0 |
| let c0:=campk p.I |
| let B:=scaleC c0 p.lid s.l.x f.info |
| have hz : B.v=p.R s:=scalen (stable_home w.st) p.lid |
| rw [← hz] |
| apply Chor.played w.st w.he (fun x _=>rfl) |
| rw [hz]; exact (abs_of_pos (mass0 ..)).le |
| |
| abbrev paid (p:Board)(s:Seats)(v:Poolx):Blob:= struck (p.R s) (v.p.push v.raw) |
| lemma foam {i} (hi:i<v.m)(he:v.mayor i)(b): |
| Cext p s c T i 0 (p.guardE b) (sideq ((paid p s v).ts (v.place i)) b):=by |
| let x:=v.place i |
| let w:=h.stifle i 0; let z:=goalCost c |
| have hz:Cext p s c T i 0 (kohn 2) 2:=by exact w.rove z 2 |
| have hg:Cext p s c T i 0 (kohn 7) 7:=by exact w.rove z 7 |
| let k:ℝ:=7*max 0 (Buf.ht (v.meal i)-2*U v) |
| have he0:Cext p s c T i 0 p.shore k:=w.mult0 hg (w.up0 w.sil (w.dubs (h.sky hi) |
| (w.mult0 hz (h.aurora (Or.inr hi))))) |
| let L:=Buf.line (Z v); let r:=sideq L b |
| have hr:Cext p s c T i 0 (p.border b) r:=h.blankx (Or.inr hi) b |
| have he1:=w.clips (h.heights i) (w.additions hr (w.clips he0 (w.dubs (h.bowlC hi b) hr))) |
| have hA : |
| sideq ((paid p s v).ts (v.place i)) b= |
| sat (p.R s) (r+sat k (sideq (v.meal i) b-r)):=by |
| unfold paid struck Params.push k |
| rw [h.ball.serves (mem_range.2 hi) he.1] |
| cases b <;> rfl |
| rw [hA] |
| apply w.ring0 he1; exact sat_size (mass0 p.lid s.d).le _ |
| |
| end Holds |
| end |
| end ExactDerandomization.Reed.Board |
| |
| end |
| |
| section |
| |
| namespace ExactDerandomization.Reed |
| open Counter Relay Rill Fret Buf Analysis Hie At Finset Seats Poolx Poolx.Nice Lu Board |
| open Fret.Lyric Holds |
| noncomputable section |
| namespace Test |
| def heated (y:ℕ) : Cub (ℕ×Coin) ℕ:= |
| ⟨fun _ a=>if Coin.low a.2 (Coin.ofZ y) then 0 else 1, |
| (Coin.lowerK Kn.next (Kn.fix _)).cond (Kn.fix 0) (Kn.fix 1)⟩ |
| abbrev draw (f:Lyric)(j:ℕ):ℕ:= f.weight+j+6 |
| def arm (f:Lyric)(k:Knob)(u j:ℕ): Badge:=⟨choir k f,k,f.weight,draw f j,heated u⟩ |
| |
| abbrev extra (f:Lyric)(j) := draw f j + f.tail |
| lemma f_marg (d i j:ℕ)(hd:1 ≤ d): |
| massB i d*2/(2:ℝ)^((i+j+6)*d) < (massB j d)⁻¹/2 := by |
| change massB i d*2/massB (i+j+6) d<_ |
| have hi:=mass0 i d; have hj:=mass0 j d |
| have hx:4 < massB 6 d:=by have h:=swellB (c:=6) hd; norm_num at h; linarith |
| rw [mass_mul,mass_mul] |
| field_simp; nlinarith |
| |
| def seatC(f:Lyric) (c):=f.cost c +100 |
| |
| lemma felt {f k c T s j X} (hp:Standard s k T)(he:Chor k c T s f X)(hz:1 ≤ c)(ht:extra f j*s.d ≤ T) (u:ℕ): |
| let B:=arm f k u j |
| ∃ a:ℕ,a ≤ 1∧s.rite (B.tariff (seatC f c)) B.check a ∧ |
| (a=0→ X ≤ u+(massB j s.d)⁻¹/2) ∧ (a≠0→ (u:ℝ)-(massB j s.d)⁻¹/2 < X):=by |
| dsimp only; let B:=arm f k u j |
| let t:=B.m*s.d |
| let c0:=seatC f c |
| obtain ⟨w,h⟩:=flex (sing he hz (H:=t) (by unfold t B arm; unfold extra at ht; rwa [add_mul] at ht)) |
| (cost_hi hz) (show f.cost c ≤ seatC f c by unfold seatC; omega) le_rfl |
| let Q:Coin:=Coin.mult (scaleC k B.i s.l.x s.info) (Coin.place (w t) (2^t)) |
| let a:= (heated u).f s.l.x (s.info,Q) |
| have hh: a=0∨a=1:=by unfold a heated; dsimp only; split <;> simp |
| have hz0: Align s.head k:=stable_home hp.st |
| have hd:1 ≤ s.d:=hz0.1.1 |
| have hx:B.i=f.weight:=rfl |
| have hA:=B.accuracy (s:=s.head) hz0 (h _ s.hm).1 |
| change |Q.v-X| ≤ massB f.weight s.d*2/(2:ℝ)^((f.weight+j+6)*s.d) at hA |
| obtain ⟨h1,h2⟩:= abs_lt.1 (hA.trans_lt (f_marg s.d f.weight j hd)) |
| have hu : a=0 ↔ Q.v ≤ u:=by |
| unfold a heated |
| simp only [ite_eq_left_iff,Coin.low_eq,Coin.ofv]; norm_num |
| refine ⟨a,by omega,fun x hx=>?_,fun ht=>by have h:=hu.1 ht; linarith, |
| fun ht=>by have h:=not_le.1 (mt hu.2 ht); linarith⟩ |
| have hM:4 ≤ c0:=by unfold c0 seatC; omega |
| refine B.query (hp.st x hx) (by change 1 ≤ c0; omega) rfl (h x hx) ?_ rfl |
| · unfold Punct; change lb a+1 ≤ c0*s.d |
| rcases hh with ha|ha <;> simp only [ha,lb_one,lb_zero] <;> nlinarith |
| end Test |
| |
| namespace Board |
| variable (p:Board) |
| abbrev heatp:Badge:=Test.arm p.riseR (campk p.I) 2 0 |
| abbrev touchp:Badge:=Test.arm p.harsh (campk p.I) 0 p.lips |
| def melt := transformed ⟨_,centerK⟩ p.heatp.check |
| abbrev keep0 :Cog:=Cargo.choose p.touchp.check nothingX p.offer |
| |
| def jack :Seek:=⟨p.bridgeQ true leftQ,p.keep0⟩ |
| def shift :Cog:=Cargo.choose p.melt p.jack.latch nothingX |
| |
| def bankC (c:ℕ) := p.heatp.tariff (Test.seatC p.riseR (goalCost c)) + |
| p.touchp.tariff (Test.seatC p.harsh (goalCost c)) +goalCost c |
| abbrev burn :=Test.extra p.riseR 0 + Test.extra p.harsh p.lips |
| abbrev payC(c:ℕ):=16*(16*(p.bankC c)) |
| |
| structure Broom (p:Board)(s:Seats)(c:ℕ)(v:Poolx) where |
| hot:ℕ |
| marked:ℕ → ℕ |
| namespace Broom |
| variable {p:Board}{s:Seats}{v:Poolx}{c} |
| def reach (b:Broom p s c v):Finset ℕ:= if b.hot=0 then Seek.part b.marked v.m else ∅ |
| def answer (b:Broom p s c v)(i:ℕ):ℕ:= if b.hot=0 then (Seek.relief b.marked i v.m).2 else 0 |
| structure Fell (b:Broom p s c v):Prop where |
| matches0 :∀ i∈v.P,b.marked i≠0→ b.marked i=v.tag i∧v.mayor i∧U v<ht (v.meal i) |
| total :∀ i∈v.P,v.mayor i→2*U v<ht (v.meal i) → b.marked i≠0 |
| lands :b.hot≠0→1 ≤ U v |
| crests :b.hot=0→U v<4 |
| arrival :∀ i:ℕ, (film s i 0).rite (p.payC c) p.shift (b.answer i) ∧ Punct s.head (p.payC c) (b.answer i) |
| |
| end Broom |
| |
| namespace Holds |
| variable {p:Board}{s c T v}(h:Holds p s c T v) |
| include h |
| omit h in |
| private lemma pay_arc : 1 ≤ p.heatp.tariff (Test.seatC p.riseR (goalCost c))∧ |
| 1 ≤ p.touchp.tariff (Test.seatC p.harsh (goalCost c)):=by |
| unfold Badge.tariff Oven.price Oven.bill Badge.tariffStart; omega |
| |
| lemma brooms (hr:p.burn*s.d ≤ T):∃ b:Broom p s c v,b.Fell:=by |
| have hf:Test.extra p.riseR 0*s.d ≤ T ∧ Test.extra p.harsh p.lips*s.d ≤ T:=by |
| unfold burn at hr; rw [add_mul] at hr; omega |
| let c0:= goalCost c; let z:=p.bankC c |
| have he:=h.pri; have hP:=(pay_arc (p := p) (c := c)); have hk:=h.currency |
| have hM:z≥ c0∧z≥2:=by unfold z c0 bankC goalCost; omega |
| let u:=U v |
| obtain ⟨a,ha,hv,hA,hB⟩:=Test.felt (h.stifle 0 0) (h.aurora (i:=0) (Or.inl rfl)) hk.2.2 hf.1 2 |
| have hl:a=0→u < 4:=by intro h0; specialize hA h0; norm_num [massB] at hA; change u ≤ _ at hA; linarith |
| have hl' : a≠0 →1 ≤ u:=by intro h1; specialize hB h1; norm_num [massB] at hB; change _ < u at hB; linarith |
| have hm (i:ℕ): (film s i 0).rite z p.melt a:= |
| importD ⟨_,centerK⟩ (centeral _ i 0) |
| (higher hv hP.1 (by unfold z bankC heatp; omega)) |
| let D:ℝ:= (massB p.lips s.d)⁻¹ |
| have hd:D ≤ u:=le_trans h.costrho.1 (v.p.U_rho v.raw (by linarith [h.costrho.2])) |
| have hg0:0<D:=by unfold D; positivity |
| have hx(i:ℕ):∃ w,i<v.m → |
| (film s i 0).rite z p.keep0 w ∧ Punct s.head z w ∧ |
| (w≠0 → w=v.tag i ∧v.mayor i ∧ u<ht (v.meal i)) ∧ |
| (v.mayor i→2*u<ht (v.meal i) → w≠0):=by |
| by_cases hi:i<v.m |
| · obtain ⟨e,he1,hv,hA,hB⟩:=Test.felt (h.stifle i 0) (h.trench hi) hk.2.2 hf.2 0 |
| let y:=ht (v.meal i) |
| change _ → 2*y-3*u ≤ (0:ℕ)+D/2 at hA |
| change _ → ((0:ℕ):ℝ)-D/2 < 2*y-3*u at hB |
| norm_num at hA hB |
| have ht:=higher hv hP.2 (show _ ≤ z by unfold z bankC touchp; omega) |
| have hr:=h.tagM i hi |
| by_cases hj:e=0 |
| · refine ⟨0,fun _=>⟨Seats.steer ht (fun _=> Seats.blankD (h.act i 0) hM.2) |
| (fun hm=> (hm hj).elim),punct0 (stable_home h.good).1 hM.2,by simp,?_⟩⟩ |
| intro h1 h2; change 2*u<y at h2 |
| have hu:v.p.rho >0:=lt_of_lt_of_le hg0 h.costrho.1 |
| have hZ:= hA hj; have hu0:v.p.rho ≤ u:=v.p.U_rho _ (by linarith [h.costrho.2]); linarith |
| refine ⟨solar v i,fun _=>⟨Seats.steer ht (fun hm=> (hj hm).elim) |
| (fun _=>higher (h.book hi) (by unfold postC; omega) |
| (by unfold goalCost at *; unfold c0 goalCost at hM; omega)),?_ ,?_,?_⟩⟩ |
| · unfold solar |
| split |
| · exact punct_up hr.2 (hk.2.1.trans hM.1) |
| exact punct0 (stable_home h.good).1 hM.2 |
| · intro hw; have hu:=(nowEQ v i).1 hw |
| refine ⟨ite_eq_left hu,hu,?_⟩ |
| have hz:=hB hj; change u<y; linarith |
| intro ht _; exact (nowEQ v i).2 ht |
| exact ⟨0,fun hl=> (hi hl).elim⟩ |
| choose w hw using hx |
| let b:Broom p s c v:=⟨a,w⟩ |
| refine ⟨b,⟨fun i hi=>(hw i (mem_range.1 hi)).2.2.1, |
| fun i hi=>(hw i (mem_range.1 hi)).2.2.2,hl',hl,fun i=>?_⟩⟩ |
| let f:=film s i 0 |
| have hh:=higher (hm i) (by omega) (show z ≤ p.payC c by unfold payC; unfold z; omega) |
| have hp:=h.act i 0 |
| by_cases hq:a=0 |
| · change f.rite _ p.shift _ ∧ _ |
| have hmN:p.jack.N f=v.m:=by change (rootsD _).f s.l.x f.info=_; unfold f; rw [numbers]; exact h.N |
| have hmK:p.jack.b.key f.head=i:=by simp [jack,Branch.key,f,bridgeQ,leftQ,film,info,panelx] |
| have hz:p.bankC c=z:=rfl |
| have he:=p.jack.earns hp hM.2 w (hmN ▸ (punct_up h.coverM (hk.2.1.trans hM.1))) |
| (fun j hj=>by |
| rw [hmN] at hj |
| have hg:f.bench p.jack.b j=film s j 0:= by exact p.backBE s true i 0 _ j |
| rw [hg]; exact ⟨(hw j hj).2.1,(hw j hj).1⟩) |
| dsimp only at he |
| have heX:b.answer i=(Seek.relief w i v.m).2:=ite_eq_left hq |
| rw [hmK,hmN] at he; rw [heX] |
| exact ⟨Seats.steer hh (fun _=>he.2) (fun h1=>(h1 hq).elim),punct_up he.1 |
| (by unfold payC; unfold z; omega)⟩ |
| have heX:b.answer i=0:=ite_eq_right hq |
| have hx0: 2 ≤ p.payC c:=by unfold z at hM; unfold payC; omega |
| rw [heX]; exact ⟨Seats.steer hh (fun y=> (hq y).elim) |
| (fun _=> Seats.blankD hp hx0),punct0 (stable_home h.good).1 hx0⟩ |
| end Holds |
| end Board |
| end |
| end ExactDerandomization.Reed |
| |
| end |
| |
| section |
| |
| namespace ExactDerandomization.Reed.Board |
| open Counter Relay Rill Fret Buf Analysis Hie At Finset Seats Poolx Poolx.Nice Lu Board |
| open Fret.Lyric Holds Broom |
| noncomputable section |
| variable (p:Board) |
| |
| /-- Routes the packed choice back to the walk head (outer i replaced by the packed rep index). -/ |
| def rearm (x:Word)(a:History):ℕ:= stairs true x (a.1,(dec a.2:History).1) |
| lemma rearmK:Kn rearm:=(stairK true).comp (Kn.first.tuple (((Kn.unpack (α:=History)).comp Kn.next).left)) |
| abbrev scoreMood (p:Board)(b:Bool):Cog:=choir (campk p.I) (p.guardE b) |
| abbrev plaza (b:Bool): Cog:= transformed ⟨_,centerK⟩ (choir (campk p.I) (p.borderE b)) |
| abbrev primary := p.plaza true |
| def rateMood (b:Bool):Cog:=Cargo.choose p.shift (p.plaza b) |
| (Cargo.combine p.shift (scoreMood p b) ⟨_,rearmK⟩) |
| abbrev hills(b:Bool):=(p.guardE b).tail+(p.borderE b).tail |
| abbrev prompt :=p.hills true+p.hills false+p.burn |
| abbrev vibes (c)(b:Bool):= (p.guardE b).cost (goalCost c) + (p.borderE b).cost (goalCost c) |
| abbrev tuneC (c:ℕ):=p.payC c + c + p.vibes c true + p.vibes c false |
| abbrev totalC(c:ℕ):=4*(p.tuneC c) |
| |
| lemma pays_sides {T i H}(b)(he:H+p.prompt*i ≤ T): |
| H+(p.guardE b).tail*i ≤ T ∧ H+(p.borderE b).tail*i ≤ T:=by |
| unfold prompt hills at he; simp only [add_mul] at he |
| cases b <;> omega |
| lemma tune_sides {c}(b): (p.guardE b).cost (goalCost c) ≤ p.tuneC c ∧ |
| (p.borderE b).cost (goalCost c) ≤ p.tuneC c:=by |
| cases b <;> unfold tuneC vibes <;> omega |
| |
| namespace Broom |
| variable {p:Board}{s:Seats}{v:Poolx}{c} |
| def product (b:Broom p s c v): Blob := if b.hot=0 then paid p s v else Run.die (paid p s v) |
| abbrev who (b:Broom p s c v)(i:ℕ):ℕ:=Relay.mark (b.answer i) |
| abbrev spot (b:Broom p s c v)(i:ℕ):ℕ:= v.place (b.who i) |
| def valueq (b:Broom p s c v)(i:ℕ)(a:Bool):ℝ:= if b.answer i=0 then sideq (line (Z v)) a else |
| sideq (b.product.ts (b.spot i)) a |
| |
| namespace Fell |
| variable {b:Broom p s c v}(g:b.Fell) |
| include g |
| lemma there {i}(hi:i∈b.reach):i∈v.P ∧ v.mayor i ∧ U v<ht (v.meal i):=by |
| unfold reach at hi; split at hi |
| · next e=> |
| obtain ⟨ha,hb⟩:=mem_filter.1 hi |
| exact ⟨ha,(g.matches0 i ha hb).2⟩ |
| simp at hi |
| lemma capacity (hv:v.Nice): b.reach.card ≤ v.p.n:=by |
| by_cases hz:b.hot=0 |
| · exact hv.whole (fun _ he=> (g.there he).1) (g.crests hz) (fun _ he=> (g.there he).2) |
| simp [reach,hz] |
| lemma locale {i}(he:b.answer i≠0): |
| b.hot=0 ∧ b.who i∈b.reach ∧ b.answer i=Seek.bin (b.who i) (v.tag (b.who i)) ∧ |
| (Seek.part b.marked (b.who i)).card=i:=by |
| unfold answer at he |
| by_cases hg:b.hot=0 |
| · rw [ite_eq_left hg] at he |
| obtain ⟨j,h1,h2,h3⟩:= (Seek.casebook b.marked i v.m).resolve_left he |
| have hu:b.answer i=Seek.bin j (b.marked j):=(ite_eq_left hg).trans h3 |
| have hh:b.who i=j:=by unfold who; rw [hu]; simp [Seek.bin,Relay.mark] |
| have ht :=mem_filter.1 h1 |
| have ha :b.marked j=v.tag j :=(g.matches0 j ht.1 ht.2).1 |
| unfold reach; rw [hh,ite_eq_left hg] |
| exact ⟨hg,h1,ha ▸ hu,h2⟩ |
| rw [ite_eq_right hg] at he; contradiction |
| |
| omit g in |
| lemma allot {i}:b.answer i≠0 ↔ i< b.reach.card:=by |
| unfold answer reach; split |
| · simp only [ne_eq,Seek.missed,not_le] |
| simp |
| omit g in |
| lemma locates {j}(he:j∈b.reach): ∃ i,b.answer i≠0 ∧ b.who i=j:= by |
| unfold reach at he; split at he |
| · next hg=> |
| obtain ⟨h1,h2⟩:=mem_filter.1 he |
| let i:=(Seek.part b.marked j).card |
| have hp:b.answer i=Seek.bin j (b.marked j):=(ite_eq_left hg).trans (Seek.order (mem_range.1 h1) h2 rfl) |
| refine ⟨i,?_,?_⟩ |
| · rw [hp]; exact ne_of_gt (Seek.binpos j _) |
| unfold who; rw [hp,Relay.marked] |
| simp at he |
| lemma sole {i j} (he:b.answer i≠0)(hz:b.answer j≠0)(_:v.Nice) |
| (hk:b.spot i=b.spot j):i=j:=by |
| have hh:=g.locale he; have hg:=g.locale hz |
| have hm:b.who i=b.who j:=(Poolx.Nice.unique (v := v)) (g.there hh.2.1).2.1 (g.there hg.2.1).2.1 hk |
| exact hh.2.2.2.symm.trans (hm.symm ▸ hg.2.2.2) |
| lemma framed (hv:v.Nice)(hr: 4 ≤ p.R s) (i) (hi:i∈v.S) |
| (he:∀ j,b.answer j≠0→ b.spot j≠i): |
| b.product.ts i=line (Z v):=by |
| unfold product; split |
| · next hc=> |
| refine hv.coverHome (B:=b.reach) ?_ _ hr hi ?_ |
| · intro i hi hv hp |
| unfold reach; rw [ite_eq_left hc] |
| exact mem_filter.2 ⟨hi,g.total i hi hv hp⟩ |
| intro hd |
| obtain ⟨j,hg,hj⟩:=mem_image.1 hd |
| obtain ⟨m,h1,h2⟩:=(locates (b := b)) hg |
| apply he m h1; unfold spot; rw [h2,hj] |
| rfl |
| |
| end Fell |
| end Broom |
| |
| namespace Holds |
| variable {p:Board}{s:Seats} {c T v} (h:p.Holds s c T v) |
| include h |
| |
| lemma tune1 : 1 ≤ p.tuneC c:=by have:=h.pri; unfold tuneC; omega |
| lemma tune0 : 1 ≤ p.payC c ∧ p.payC c ≤ p.tuneC c ∧ p.tuneC c ≤ p.totalC c:=by |
| have:=tune1 h; have:=h.pri |
| unfold tuneC payC bankC totalC goalCost at * |
| unfold tuneC payC bankC goalCost |
| omega |
| |
| lemma baseHear {H}(hr:H+p.prompt*s.d ≤ T)(i:ℕ)(b): (film s i 0).band (p.tuneC c) H p.lid (p.plaza b) |
| (sideq (line (Z v)) b):=by |
| let u:=h.boardU (i:=0) (Or.inl rfl) b |
| let z:= goalCost c |
| have hh : 1 ≤ z:=h.currency.2.2 |
| apply transportD ⟨_,centerK⟩ (centeral s i 0) |
| exact flex (sing u hh (p.pays_sides b hr).2) (cost_hi hh) (p.tune_sides b).2 le_rfl |
| |
| lemma turmoil {b:Broom p s c v}(g:b.Fell){H}(hr:H+p.prompt*s.d ≤ T)(i)(a): |
| (film s i 0).band (p.totalC c) H p.lid (p.rateMood a) (b.valueq i a):=by |
| let C:=p.tuneC c |
| have hh:=h.tune0; have hc:=h.tune1; have he:=g.arrival i |
| have ht:= higher he.1 hh.1 hh.2.1 |
| apply Seats.avis (higher ht hc hh.2.2) |
| · intro hz; rw [Broom.valueq,ite_eq_left hz] |
| exact flex (h.baseHear hr i a) hc hh.2.2 le_rfl |
| intro hp |
| rw [Broom.valueq,ite_eq_right hp] |
| obtain ⟨hu,h1,h2,h3⟩:=g.locale hp |
| obtain ⟨h4,h5,h6⟩:=g.there h1 |
| have hz := sing (h.foam (mem_range.1 h4) h5 a) h.currency.2.2 (p.pays_sides a hr).1 |
| unfold Broom.product |
| rw [ite_eq_left hu] |
| let f:=film s i 0; let k:Cub History ℕ:=⟨_,rearmK⟩ |
| have hk: berth k f (b.answer i) = film s (b.who i) 0:=by simp [berth,k,panelx,f,film, |
| rearm,stairs,who,Relay.mark,info] |
| apply advises (h.act i 0) (punct_up he.2 hh.2.1) hc ht |
| rw [hk] |
| exact flex hz (cost_hi h.currency.2.2) (p.tune_sides a).1 le_rfl |
| |
| end Holds |
| |
| /-- Package for a single executable prefix update, all higher-precision probes. -/ |
| structure Page (s:Seats)(c T:ℕ)(v:Poolx)(b:Broom p s c v):Prop where |
| fell: b.Fell |
| iex:1 ≤ p.totalC c |
| transact :∀ i, Punct s.head (p.totalC c) (b.answer i) ∧ (film s i 0).rite (p.totalC c) p.shift (b.answer i) |
| wave :∀ i a H,H+p.prompt*s.d ≤ T → |
| (film s i 0).band (p.totalC c) H p.lid (p.rateMood a) (b.valueq i a) |
| baseP :∀ i H,H+p.prompt*s.d ≤ T → (film s i 0).band (p.totalC c) H p.lid p.primary (Z v) |
| theorem mounted {s c T v} (h:Holds p s c T v) (hr:p.prompt*s.d ≤ T): |
| ∃ b, Page p s c T v b:=by |
| obtain ⟨b,hb⟩:= brooms h (by exact le_trans (Nat.mul_le_mul_right _ (by unfold prompt; omega)) hr) |
| have hp:=tune0 h |
| have he:=hp.2.1.trans hp.2.2 |
| exact ⟨b,hb,(tune1 h).trans hp.2.2,fun i=> |
| ⟨punct_up (hb.arrival i).2 he,higher (hb.arrival i).1 hp.1 he⟩, |
| fun i a _ hz=>turmoil h hb hz i a,fun i H hz=> |
| flex (h.baseHear hz i true) (h.tune1) hp.2.2 le_rfl⟩ |
| |
| end |
| end ExactDerandomization.Reed.Board |
| |
| end |
| |
| end OAI |
| |
