| import OAI.Computability.Logspace.AffineSampling |
| import OAI.Computability.Logspace.CompressionBounds |
| import OAI.Computability.Logspace.ProbabilityAtoms |
|
|
| namespace OAI |
|
|
| /-! |
| Fourth-root norms and integrated error estimates for the compressed estimator. |
|
|
| From OpenAI, *Exact Derandomization of Logarithmic Space: L = RL = BPL*. |
| -/ |
|
|
| set_option autoImplicit true |
|
|
| section |
|
|
| /-! Dyadic estimates, with nonnegative integer exponents only. -/ |
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis At Hie Buf Finset |
|
|
| def box (i : ℕ) : ℝ := 2^i |
| def dry (i : ℕ) : ℝ := (box i)⁻¹ |
| lemma box0 (i) : 0<box i := by unfold box; positivity |
| lemma dry0 (i) : 0<dry i := by unfold dry; have := box0 i; positivity |
| lemma box_one (i) : 1≤box i := by unfold box; exact one_le_pow₀ (by norm_num) |
| lemma dry_one (i) : dry i ≤ 1 := by unfold dry; exact inv_le_one_of_one_le₀ (box_one i) |
| lemma boxP (i j : ℕ) : box (i+j)=box i*box j := pow_add .. |
| lemma dryP (i j : ℕ) : dry (i+j)=dry i*dry j := by simp only [dry,boxP,mul_inv] |
| lemma boxM (i j) : box (i*j)=(box i)^j := pow_mul .. |
| lemma dryM (i j) : dry (i*j)=(dry i)^j := by simp only [dry,boxM,inv_pow] |
| lemma unify (i) : box i * dry i=1 := by unfold dry; rw [mul_inv_cancel₀ (box0 i).ne'] |
| lemma reunite (i) : dry i*box i=1 := by rw [mul_comm,unify] |
| lemma box_mono : Monotone box := by |
| intro a b e; unfold box; gcongr; linarith |
| lemma dry_mono : Antitone dry := by |
| intro a b e; unfold dry; exact inv_anti₀ (box0 a) (box_mono e) |
|
|
| lemma exp_big (n : ℕ) : n+1≤2^n := by |
| induction n with |
| | zero=>simp |
| | succ n ih=> rw [pow_succ]; omega |
| lemma box_big (n : ℕ) : (n:ℝ)+1≤box n := by unfold box; exact_mod_cast exp_big n |
|
|
| lemma invsum (n : ℕ) : ∑ i∈ range n,dry i = 2-2*dry n := by |
| induction n with |
| | zero=> norm_num [dry,box] |
| | succ n ih=> rw [sum_range_succ,ih,dryP] |
| norm_num [dry,box]; ring |
| lemma thinSum (F : Domain) : ∑ i∈F,dry i ≤2 := by |
| let n:=1+∑ i∈F,i |
| have he : F⊆range n := by |
| intro i hi; have hs:i ≤ ∑ i∈F,i:=single_le_sum (f:=fun i=>i) (fun _ _=> Nat.zero_le _) hi |
| apply mem_range.mpr; dsimp only [n]; omega |
| apply le_trans (sum_le_sum_of_subset_of_nonneg he (fun i hi _=>(dry0 i).le)) |
| rw [invsum]; linarith [dry0 n] |
|
|
| /-- d-index of slack group number i, descending. -/ |
| def gapD (L i : ℕ) := 2^(L-1-i) |
| lemma gap_end (L : ℕ) : gapD L (L-1)=1 := by simp [gapD] |
| lemma gapD_pos (L i) : 1≤gapD L i := show 0<gapD L i from pow_pos (by omega) _ |
| lemma gapD_succ {L i} (hi : i+1<L) : gapD L i=gapD L (i+1)*2 := by |
| unfold gapD |
| rw [show L-1-i=L-1-(i+1)+1 by omega,pow_succ] |
| lemma gapD_mono {L} : Antitone (gapD L) := by |
| intro i j h; unfold gapD |
| exact Nat.pow_le_pow_right (by omega) (by omega) |
| lemma gapD_tail {L i} (hi : i<L) : L-i ≤ gapD L i := by |
| apply le_trans _ (exp_big (L-1-i)); omega |
|
|
| lemma binsum (L : ℕ) : ∑ i ∈ range L, dry (gapD L i) ≤2 := by |
| rw [← sum_image (f:=dry)] |
| · apply thinSum |
| · intro i hi j hj e; replace hi:=mem_range.1 hi; replace hj:=mem_range.1 hj |
| rcases lt_trichotomy i j with hs|hs|hs |
| · have h := gapD_succ (L:=L) (i:=i) (by omega) |
| have h1 : gapD L j ≤gapD L (i+1) := gapD_mono (by omega) |
| have hh:=gapD_pos L i; omega |
| · exact hs |
| · have h := gapD_succ (L:=L) (i:=j) (by omega) |
| have h1 : gapD L i ≤gapD L (j+1) := gapD_mono (by omega) |
| have hh:=gapD_pos L j; omega |
| lemma cyclo {L i} (hi:i<L) : (32:ℝ)^(L-i) ≤ box (5*gapD L i) := by |
| have hs:=gapD_tail hi |
| unfold box; rw [pow_mul] |
| norm_num; gcongr; norm_num |
|
|
| /-- Abstract compression exponent packet with abundant room for both |
| masked mean and false positives charges. -/ |
| def fexpo (b : ℕ) := b+100 |
| def cexpo (b K : ℕ) := fexpo b+b+10+K |
|
|
| def floorR (b L i : ℕ) := dry (fexpo b*gapD L i) |
| def capacity (b K L i : ℕ) := 2^(cexpo b K*gapD L i*4) |
| def liftB (b L i : ℕ) := box (b*gapD L i) |
| def decay (L i : ℕ) := dry (8*gapD L i) |
| def firm (b _ L i : ℕ) := dry ((b+10)*gapD L i) |
|
|
| lemma floor_pos (b L i) : 0<floorR b L i := dry0 _ |
| lemma lift_one (b L i) : 1≤liftB b L i := box_one _ |
| lemma decay_le (b L i) : decay L i≤ liftB b L i := le_trans (dry_one _) (lift_one ..) |
| lemma cap_pos (b K L i) : 0<capacity b K L i := pow_pos (by omega) _ |
| lemma cap_K (b K L i) : K ≤ capacity b K L i := by |
| apply le_trans _ (exp_big (cexpo b K*gapD L i*4)) |
| have he := gapD_pos L i; have ht : K≤ cexpo b K := by unfold cexpo; omega |
| nlinarith |
| lemma cap_box (b K L i) : (capacity b K L i:ℝ)=box (cexpo b K*gapD L i)^4 := by |
| simp only [capacity,box,Nat.cast_pow,Nat.cast_ofNat,pow_mul] |
|
|
| lemma forfeit (b K L i) : |
| 1≤ (capacity b K L i:ℝ)*(floorR b L i)^4*(firm b K L i)^4 := by |
| rw [cap_box,← mul_pow,← mul_pow] |
| apply one_le_pow₀ |
| let d:=gapD L i |
| let s:=fexpo b*d+(b+10)*d |
| have h : s ≤ cexpo b K*d:=by unfold s cexpo; grind |
| unfold floorR firm |
| rw [mul_assoc,← dryP]; change 1≤box _*dry s |
| conv_lhs=> rw [← unify s] |
| exact mul_le_mul_of_nonneg_right (box_mono h) (dry0 _).le |
| lemma feed_power (b K L i) : |
| 1 ≤ (capacity b K L i:ℝ)*floorR b L i*(firm b K L i)^4 := by |
| have hs:= forfeit b K L i; apply le_trans hs |
| gcongr |
| exact le_trans (pow_le_pow_of_le_one (floor_pos ..).le (dry_one _) |
| (show 1≤ (4:ℕ) by omega)) (by rw [pow_one]) |
|
|
| lemma floor_lift (b L i) : floorR b L i*liftB b L i ≤ dry (gapD L i) := by |
| let d:=gapD L i |
| unfold floorR liftB; rw [fexpo,add_mul,dryP,mul_right_comm, reunite, one_mul] |
| apply dry_mono; omega |
| lemma firm_plain (b K L i) : firm b K L i*liftB b L i≤dry (gapD L i) := by |
| unfold firm liftB; rw [add_mul,dryP,mul_right_comm,reunite,one_mul] |
| apply dry_mono; omega |
| lemma firm_big (b K L i) : firm b K L i*box ((b+6)*gapD L i) ≤ dry (gapD L i) := by |
| unfold firm; rw [show b+10=b+6+4 by omega, add_mul (b+6),dryP,mul_right_comm,reunite,one_mul] |
| apply dry_mono; omega |
| lemma cyclone {L i} (hi : i<L) : (32:ℝ)^(L-i)*decay L i≤dry (gapD L i) := by |
| apply le_trans (mul_le_mul_of_nonneg_right (cyclo hi) (dry0 _).le) |
| change box _*dry (8*gapD L i)≤_ |
| let d:=gapD L i |
| rw [show 8*gapD L i=5*gapD L i+3*gapD L i by omega,dryP,← mul_assoc,unify,one_mul] |
| apply dry_mono; omega |
| lemma firm_tail (b K L i) (hi:i<L) : |
| firm b K L i * ∑ j∈ Ico i L, (32:ℝ)^(L-j)*liftB b L j ≤ dry (gapD L i) := by |
| let d := gapD L i; let C:=box ((b+5)*d) |
| apply le_trans _ (firm_big b K L i) |
| apply mul_le_mul_of_nonneg_left _ (dry0 _).le |
| have he : ∀ j∈Ico i L,(32:ℝ)^(L-j)*liftB b L j ≤ C := by |
| intro j hj |
| obtain ⟨he,hj⟩:=mem_Ico.mp hj |
| have hz : gapD L j ≤ d := gapD_mono he |
| unfold C liftB; rw [add_mul,boxP,mul_comm (box (b*d))] |
| exact mul_le_mul ((cyclo hj).trans (box_mono (by gcongr))) (box_mono (by gcongr)) |
| (box0 _).le (box0 _).le |
| have hz : (L-i:ℕ) ≤ d:=gapD_tail hi |
| have hn : ((L-i:ℕ):ℝ)≤box d := |
| le_trans (b:=(d:ℝ)) (by exact_mod_cast hz) (by linarith [box_big d]) |
| calc _ ≤ _ := sum_le_sum he |
| _ = ((L-i:ℕ):ℝ)*C := by simp |
| _ ≤ box d*C := mul_le_mul_of_nonneg_right hn (box0 _).le |
| _ = _ := by unfold C; rw [← boxP]; dsimp [d]; congr 1; ring |
|
|
| lemma min_chill (b L i) : floorR b L i ≤dry (gapD L i)* dry 80 := by |
| rw [← dryP]; apply dry_mono |
| have hv := gapD_pos L i |
| unfold fexpo; nlinarith |
| lemma first_bound (b L i) : floorR b L i ≤ 1/1024 := by |
| have hg:= le_trans (min_chill b L i) (mul_le_mul_of_nonneg_right (dry_one _) (dry0 _).le) |
| norm_num [dry,box] at hg; linarith |
| lemma totaldust (b L) : ∑ i∈range L,6*floorR b L i≤ At.small := by |
| apply le_trans (b:=6*(∑ i∈range L,dry (gapD L i))*dry 80) |
| · rw [mul_sum,sum_mul]; exact sum_le_sum fun i hi=>by rw [mul_assoc]; gcongr; apply min_chill |
| have h := mul_le_mul_of_nonneg_right (binsum L) (dry0 80).le |
| norm_num [dry,box,small,delta,A] at *; linarith |
|
|
| lemma freezeD (b L i : ℕ) (h : i+1<L) : |
| floorR b L i=floorR b L (i+1)*floorR b L (i+1) := by |
| simp only [floorR,gapD_succ h] |
| rw [← dryP]; congr 1; ring |
|
|
| lemma lead_dust (b L i : ℕ) (hi:i<L) : |
| ∑ j∈ range i,6*floorR b L j ≤floorR b L i/100 := by |
| induction i with |
| | zero=>simp; linarith [floor_pos b L 0] |
| | succ i ih=> |
| have hs := ih (by omega) |
| rw [sum_range_succ] |
| apply le_trans (add_le_add_left hs _) |
| rw [freezeD b L i hi] |
| nlinarith [first_bound b L (i+1),floor_pos b L (i+1)] |
|
|
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| section |
|
|
| /-! Measures used in the uncompressed and compressed comparisons. -/ |
| set_option synthInstance.maxSize 2048 |
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis Hie At Finset |
|
|
| variable {n w : ℕ} [Fact n.Prime] |
|
|
| abbrev X (n w : ℕ) := Env n w |
| abbrev src (S : Domain) (u : ℕ) (s : X n w) := retain u S s.1 |
| abbrev dst (S : Domain) (a : ℕ) (s : X n w) := retain a S s.2.1 |
|
|
| abbrev Vertex (n w : ℕ) := X n w → Vec |
| abbrev TableF (n w : ℕ) := X n w → Mat |
|
|
| def scaleM (N u : ℕ) := (N*rate u)⁻¹ |
| lemma scaleM_nn (N u) : 0 ≤ scaleM N u := by unfold scaleM; have := rate_pos u; positivity |
|
|
| structure Axis where |
| S : Domain |
| N : ℕ |
| u : ℕ |
| a : ℕ |
|
|
| namespace Axis |
| variable (d : Axis) |
|
|
| def VM : Meter (X n w × ℕ) := |
| Meter.Scale (Meter.Along Meter.Avg (fun s=>Meter.Sum (src d.S d.u s))) |
| (scaleM d.N d.u) (scaleM_nn ..) |
| def TM : Meter ((X n w × ℕ) × ℕ) := |
| d.VM.Along (fun (s,_)=>Meter.Sum (dst d.S d.a s)) |
|
|
| def vi (f : Vertex n w) := d.VM.I fun (s,x)=> f s x |
| def ti (f : TableF n w) := d.TM.I fun ((s,x),y)=> f s x y |
| def von (f : Vertex n w) := d.VM.L fun (s,x)=> f s x |
| def ton (f : TableF n w) := d.TM.L fun ((s,x),y)=>f s x y |
| def terr (f g : TableF n w) := |
| d.ton (fun s i j=>fourth (f s i j)-fourth (g s i j)) |
|
|
| lemma vi_apply (f : Vertex n w) : |
| d.vi f=scaleM d.N d.u * av (fun s=>∑ i∈src d.S d.u s,f s i) := rfl |
| lemma ti_apply (f : TableF n w) : |
| d.ti f=scaleM d.N d.u * av (fun s=>∑ i∈src d.S d.u s, |
| ∑ j∈dst d.S d.a s,f s i j) := rfl |
| lemma collapse (f : TableF n w) : |
| d.ti f = d.vi (fun s i => ∑ j∈dst d.S d.a s,f s i j) := rfl |
|
|
| lemma vi_mono {f g : Vertex n w} (e : ∀ s i, i∈src d.S d.u s → f s i≤g s i) : |
| d.vi f≤d.vi g := by |
| rw [vi_apply,vi_apply] |
| exact mul_le_mul_of_nonneg_left (av_mono (fun i=>sum_le_sum (e i))) (scaleM_nn ..) |
| lemma ti_mono {f g : TableF n w} (e : ∀ s i j, i∈src d.S d.u s → j∈dst d.S d.a s → |
| f s i j≤ g s i j) : d.ti f≤ d.ti g := |
| d.vi_mono fun s i hi=>sum_le_sum fun j hj=>e s i j hi hj |
|
|
| lemma conditional (f : TableF n w) : |
| d.ti f= |
| scaleM d.N d.u*∑ i∈d.S,∑ j∈d.S, |
| pct n d.u*pct n d.a*Env.cond d.u d.a (↑i:ZMod n) (↑j:ZMod n) |
| (fun s=>f s i j) := by |
| have he (s:X n w) : |
| ∑ i∈src d.S d.u s,∑ j∈dst d.S d.a s,f s i j=∑ i∈d.S,∑ j∈d.S, |
| (if Env.mask d.u d.a (↑i:ZMod n) (↑j:ZMod n) s then f s i j else 0) := by |
| unfold src dst retain Env.mask |
| rw [sum_filter] |
| apply sum_congr rfl; intro i hi |
| rw [sum_filter]; split |
| · next e=>simp [e] |
| · next e=>simp [e] |
| rw [ti_apply]; simp_rw [he, av_sum] |
| congr! 2 |
| apply sum_congr rfl; intro j _ |
| apply Env.two_cond |
|
|
| lemma vi_const {S : Domain} (l : ℕ) : |
| av (fun s:X n w=> (#(src S l s) : ℝ)) = #S*pct n l := by |
| rw [av_prod] |
| simp_rw [src,av_const] |
| exact tally_av .. |
| lemma vi_one (hl:2^d.u ≤ n) (hc : d.S.card≤d.N) : |
| d.vi (fun (_:X n w) _=> (1:ℝ)) ≤ 16 := by |
| rw [vi_apply] |
| simp only [sum_const,nsmul_eq_mul,mul_one,vi_const] |
| obtain e|e:=Nat.eq_zero_or_pos d.N |
| · simp [scaleM,e] |
| have he:= (pct_bounds hl).2 |
| have hz : (0:ℝ)<d.N := by exact_mod_cast e |
| have hv : (d.S.card:ℝ)≤d.N := by exact_mod_cast hc |
| unfold scaleM |
| rw [← div_eq_inv_mul, div_le_iff₀ (mul_pos hz (rate_pos _))] |
| have hp := pct_pos (NeZero.pos n) d.u |
| nlinarith [mul_le_mul_of_nonneg_left he (show 0≤(d.N:ℝ) by linarith)] |
|
|
| lemma von_four (f : Vertex n w) : d.von f^4=d.vi (fun i j=>f i j^4) := by rw [von,Meter.L4]; rfl |
| lemma ton_four (f : TableF n w) : d.ton f^4=d.ti (fun i j k=>f i j k^4) := by rw [ton,Meter.L4]; rfl |
|
|
| end Axis |
|
|
| lemma panel_const (k l) (x y : ℕ) (f : Analysis.Channel n→Analysis.Channel n→ℝ) : |
| @Env.cond n w _ k l (↑x:ZMod n) (↑y:ZMod n) (fun s=> f s.1 s.2.1) = |
| atP k (↑x:ZMod n) (fun i=>atP l (↑y:ZMod n) (fun j=>f i j)) := by |
| unfold Env.cond atP; simp only [av_prod,Env.outward,av_const] |
|
|
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| section |
|
|
| set_option synthInstance.maxSize 2048 |
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis Hie At Finset |
|
|
| variable {n w : ℕ} [Fact n.Prime] |
|
|
| namespace Axis |
| variable (d : Axis) |
| lemma tn0 (f : TableF n w) : 0 ≤ d.ton f := Meter.Lnn .. |
| lemma vn0 (f : Vertex n w) : 0 ≤ d.von f := Meter.Lnn .. |
| lemma tscale (f : TableF n w) (c) : |
| d.ton (fun i j x=>c*f i j x) = |c| *d.ton f := Meter.Lmul .. |
| lemma vscale (f : Vertex n w) (c) : |
| d.von (fun i j=>c*f i j) = |c| *d.von f := Meter.Lmul .. |
| lemma tplus (f g : TableF n w) : |
| d.ton (fun i j x=>f i j x+g i j x) ≤ d.ton f+d.ton g := Meter.mink .. |
| lemma vplus (f g : Vertex n w) : |
| d.von (fun i j=>f i j+g i j) ≤d.von f+d.von g := Meter.mink .. |
| lemma tseries {A : Type} (f : A → TableF n w) (S : Finset A) : |
| d.ton (fun i j x=>∑ s∈S,f s i j x) ≤∑ s∈S,d.ton (f s) := by |
| classical |
| induction S using Finset.induction_on with |
| | empty=>simp [ton,Meter.L,Meter.m4,Meter.I0,fourth] |
| | @insert a S ha h=> |
| simp only [sum_insert ha] |
| exact le_trans (d.tplus (f a) _) (add_le_add_right h _) |
| lemma vseries {A : Type} (f : A → Vertex n w) (S : Finset A) : |
| d.von (fun i j=>∑ s∈S,f s i j) ≤∑ s∈S,d.von (f s) := by |
| classical |
| induction S using Finset.induction_on with |
| | empty=>simp [von,Meter.L,Meter.m4,Meter.I0,fourth] |
| | @insert a S ha h=> |
| simp only [sum_insert ha] |
| exact le_trans (d.vplus (f a) _) (add_le_add_right h _) |
|
|
| lemma tm_le {f : TableF n w} {c} (h:0≤c) : |
| d.ton f ≤ c ↔ d.ti (fun i j x=> f i j x^4) ≤ c^4 := Meter.LP _ h |
| lemma vm_le {f : Vertex n w} {c} (h:0≤c) : |
| d.von f≤c↔ d.vi (fun i j=> f i j^4)≤c^4 := Meter.LP _ h |
|
|
| lemma torder {f g : TableF n w} |
| (h:∀ s i j,i∈src d.S d.u s→ j∈dst d.S d.a s→ |f s i j| ≤ g s i j) : |
| d.ton f ≤ d.ton g := by |
| apply (d.tm_le (d.tn0 g)).2 |
| rw [d.ton_four] |
| exact d.ti_mono fun s i j he hh=>by |
| rw [← Meter.abs4 (f s i j)]; exact pow_le_pow_left₀ (abs_nonneg _) (h s i j he hh) 4 |
| lemma vorder {f g : Vertex n w} (h:∀ s i,i∈src d.S d.u s→|f s i| ≤ g s i) : |
| d.von f≤ d.von g := by |
| apply (d.vm_le (d.vn0 g)).2 |
| rw [d.von_four] |
| exact d.vi_mono fun s i he=>by rw [← Meter.abs4 (f s i)]; exact pow_le_pow_left₀ (abs_nonneg _) (h s i he) 4 |
| lemma vi_nn {f : Vertex n w} (h:∀ s i,i∈src d.S d.u s → 0≤ f s i) : 0≤ d.vi f := by |
| rw [d.vi_apply] |
| exact mul_nonneg (scaleM_nn ..) (av_nonneg _ fun s=>sum_nonneg (h s)) |
| lemma ti_nn {f : TableF n w} (h: ∀ s i j,i∈src d.S d.u s → j∈dst d.S d.a s → |
| 0≤f s i j) : 0≤d.ti f := |
| d.vi_nn (f:=fun s i=> ∑ j∈dst d.S d.a s,f s i j) |
| fun s i hi=>sum_nonneg fun j hj=>h s i j hi hj |
| lemma tmul (f : TableF n w) (c:ℝ) : d.ti (fun i j k=>c*f i j k)=c*d.ti f := Meter.scl .. |
| lemma vmul (f : Vertex n w) (c:ℝ) : d.vi (fun i j=>c*f i j)=c*d.vi f := Meter.scl .. |
|
|
| /-- Evaluate head of a row (L4 sum over columns), a convenient |
| alternative to suprema that still bounds them. -/ |
| def head (f : TableF n w) : Vertex n w := |
| fun s i=> (Meter.Sum (dst d.S d.a s)).L (f s i) |
| lemma head_nn (f : TableF n w) s i : 0≤ d.head f s i := Meter.Lnn .. |
| lemma head_ge (f : TableF n w) s i {y} (hy:y∈dst d.S d.a s) : |
| |f s i y| ≤d.head f s i := by |
| have hs : (f s i y)^4≤∑ k∈dst d.S d.a s,(f s i k)^4 := |
| single_le_sum (f:=fun k=>f s i k^4) (fun k _=>by positivity) hy |
| unfold head Meter.L Meter.m4 |
| conv_lhs=>rw [← four_fourth (abs_nonneg (f s i y))] |
| rw [Meter.abs4] |
| exact fourth_mono hs |
| lemma head_e (f : TableF n w) : d.von (d.head f)=d.ton f := by |
| unfold von ton Meter.L Meter.m4 |
| unfold Meter.I VM TM Meter.Along Meter.Sum Meter.Scale Meter.Avg |
| simp_rw [head, Meter.L4] |
| rfl |
| lemma head_mask (P : X n w → ℕ→Prop) [∀ s i, Decidable (P s i)] (f : TableF n w) s i : |
| d.head (fun s i j=>if P s i then f s i j else 0) s i = |
| (if P s i then d.head f s i else 0) := by |
| by_cases he:P s i <;> simp [head,he,Meter.Lzero] |
|
|
| /-- mask a deterministic array to possibly narrower terminal slices. -/ |
| abbrev narrowed (a : ℕ) : Axis := {d with a:=a} |
| def wmask (a : ℕ) (f : TableF n w) : TableF n w := |
| fun s i j=> if j∈ dst d.S a s then f s i j else 0 |
| lemma ti_mask (a : ℕ) (h:d.a≤a) (f : TableF n w) : |
| d.ti (d.wmask a f)=(d.narrowed a).ti f := by |
| unfold ti |
| have hg (s:X n w) (j) : j∈dst d.S a s→ j∈dst d.S d.a s := |
| fun e=> mem_filter.2 ⟨(mem_filter.1 e).1,contained a d.a h (mem_filter.1 e).2⟩ |
| have he (s:X n w) (i) : |
| ∑ j∈dst d.S d.a s,d.wmask a f s i j=∑ j∈dst d.S a s,f s i j := by |
| unfold wmask |
| rw [← sum_filter] |
| congr 1; ext j; simp only [mem_filter]; exact ⟨fun e=>e.2,fun e=>⟨hg s j e,e⟩⟩ |
| change scaleM _ _ * av (fun s=>∑ i∈src d.S d.u s,∑ j∈dst d.S d.a s,_) = |
| scaleM _ _ * av (fun s=>∑ i∈src d.S d.u s,∑ j∈dst d.S a s,_) |
| simp_rw [he] |
|
|
| lemma tmask_power (a : ℕ) (h:d.a≤a) (f : TableF n w) : |
| d.ton (d.wmask a f)^4=(d.narrowed a).ton f^4 := by |
| rw [d.ton_four,ton_four] |
| have he : (fun s i j=> d.wmask a f s i j^4)=d.wmask a (fun s i j=> f s i j^4) := by |
| ext s i j; unfold wmask; split <;> simp_all |
| rw [he,ti_mask d a h] |
|
|
| lemma tmask (a : ℕ) (h:d.a≤a) (f : TableF n w) : |
| d.ton (d.wmask a f)=(d.narrowed a).ton f := by |
| conv_lhs=>rw [← four_fourth (d.tn0 _)] |
| rw [tmask_power d a h,four_fourth ((d.narrowed a).tn0 _)] |
|
|
| end Axis |
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| section |
|
|
| /-! Averaging on the rate conditions, without any frozen bits. |
| In this calculation w=0. The outer variant uses deterministic exact |
| endpoint equality. -/ |
| set_option synthInstance.maxSize 4096 |
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis Hie At Finset |
|
|
| variable {n : ℕ} [Fact n.Prime] |
| abbrev Pool (n : ℕ) := Env n 0 |
| abbrev Pics (n) := TableF n 0 |
| abbrev Paint (n) := Vertex n 0 |
|
|
| /-- index-based probability scale factoring -/ |
| lemma pct_c0 (n : ℕ) [Fact n.Prime] : pct n 0=1 := by |
| rw [pct, side_zero (NeZero.pos n),div_self]; norm_num |
| exact Nat.cast_ne_zero.mpr (NeZero.ne n) |
| lemma rr (i) : rate i = dry i^4 := rfl |
|
|
| namespace Axis |
| variable (d : Axis) |
|
|
| def fm (f : Pics n) : Mat := |
| fun i j=> Env.cond d.u d.a (↑i:ZMod n) (↑j:ZMod n) (fun s=>f s i j) |
| def vm (f : Paint n) : Vec := |
| fun i=> Env.cond d.u 0 (↑i:ZMod n) 0 (fun s=>f s i) |
|
|
| def fw (l : ℕ) (f : Pics n) : Pics n := |
| fun s i j=> Env.sampling d.u d.a (↑i:ZMod n) (↑j:ZMod n) (d:=0) (w:=0) le_rfl l |
| (fun s'=>f s' i j) s |
| def vw (l : ℕ) (f : Paint n) : Paint n := |
| fun s i=> Env.sampling d.u 0 (↑i:ZMod n) 0 (d:=0) (w:=0) le_rfl l (fun s'=>f s' i) s |
|
|
| lemma fdet (f : Mat) : d.fm (n:=n) (fun _=>f)=f := by ext; simp [fm,Env.cond,av_const] |
| lemma vdet (f : Vec) : d.vm (n:=n) (fun _=>f)=f := by ext; simp [vm,Env.cond,av_const] |
| lemma fscalar (c : ℝ) (f : Pics n) i j : |
| d.fm (fun s i j=> c*f s i j) i j = c*d.fm f i j := by rw [fm,fm,Env.cond,Env.cond]; rw [av_cmul] |
| lemma fmean_sub (f g : Pics n) i j : |
| d.fm (fun s i j=> f s i j-g s i j) i j=d.fm f i j-d.fm g i j := by |
| rw [fm,fm,fm,Env.cond,Env.cond,Env.cond,av_sub] |
| lemma vmean_sub (f g : Paint n) i : |
| d.vm (fun s i=> f s i-g s i) i=d.vm f i-d.vm g i := by |
| rw [vm,vm,vm,Env.cond,Env.cond,Env.cond,av_sub] |
| lemma goodfm {f : Pics n} {i j:ℕ} {c:ℝ} (h1:∀ s, |
| hit d.u (↑i:ZMod n) s.1 → hit d.a (↑j:ZMod n) s.2.1 → 0≤f s i j∧ f s i j≤c) : |
| 0≤d.fm f i j ∧ d.fm f i j≤c := by |
| unfold fm Env.cond |
| let g (x:Env.Slice n d.u d.a 0) := |
| f (Env.outward d.u d.a (i:ZMod n) (j:ZMod n) x) i j |
| have he (x) : 0≤g x∧g x≤c:= h1 _ (Env.hits ..).1 (Env.hits ..).2 |
| refine ⟨av_nonneg g (fun i=>(he i).1),le_trans ?_ (le_of_eq (@av_const (Env.Slice n d.u d.a 0) _ _ _))⟩ |
| exact av_mono (g:=fun _=>c) fun i=>(he i).2 |
|
|
| lemma eqfm {f g : Pics n} {i j:ℕ} (h:∀ s, |
| hit d.u (↑i:ZMod n) s.1 → hit d.a (↑j:ZMod n) s.2.1 → f s i j=g s i j) : |
| d.fm f i j=d.fm g i j := by |
| unfold fm Env.cond |
| apply congrArg av; ext x |
| exact h _ (Env.hits ..).1 (Env.hits ..).2 |
|
|
| lemma eqvm {f g : Paint n} {i:ℕ} (h:∀ s,hit d.u (↑i:ZMod n) s.1 → f s i=g s i) : |
| d.vm f i=d.vm g i := by |
| unfold vm Env.cond |
| apply congrArg av; ext x |
| exact h _ (Env.hits ..).1 |
|
|
| lemma ite_wmask {a} {i j} (h:d.a≤a) (f : Pics n) (he:j∈d.S) : |
| pct n d.a*d.fm (d.wmask a f) i j = pct n a * (d.narrowed a).fm f i j := by |
| apply mul_left_cancel₀ (pct_pos (NeZero.pos n) d.u).ne' |
| rw [← mul_assoc,← mul_assoc]; unfold fm narrowed |
| rw [← Env.two_cond,← Env.two_cond]; congr 1; ext s |
| unfold wmask dst retain Env.mask |
| simp only [mem_filter,he,true_and] |
| by_cases hz:hit d.u (↑i:ZMod n) s.1 |
| · by_cases hs : hit a (↑j:ZMod n) s.2.1 |
| · simp [hs,contained a d.a h hs,hz] |
| simp [hs,hz] |
| simp [hz] |
|
|
| lemma fpivot (f : Pics n) : |
| d.ti f=scaleM d.N d.u*∑ i∈d.S,∑ j∈d.S, pct n d.u*pct n d.a*d.fm f i j := |
| d.conditional f |
| lemma vpivot (f : Paint n) : |
| d.vi f=scaleM d.N d.u*∑ i∈d.S,pct n d.u*d.vm f i := by |
| rw [vi_apply]; congr 1 |
| have he (s:Pool n) : |
| ∑ i∈src d.S d.u s,f s i=∑ i∈d.S,if Env.mask d.u 0 (↑i:ZMod n) 0 s then f s i else 0 := by |
| unfold src retain; rw [sum_filter]; simp [Env.mask,allhit] |
| simp_rw [he,av_sum] |
| refine sum_congr rfl fun i hi=>?_ |
| unfold vm; rw [Env.two_cond,pct_c0,mul_one] |
|
|
| lemma ftest {f g : Pics n} (h:∀ i∈d.S,∀ j∈d.S,d.fm f i j≤ d.fm g i j) : |
| d.ti f ≤ d.ti g := by |
| rw [d.fpivot,d.fpivot] |
| refine mul_le_mul_of_nonneg_left ?_ (scaleM_nn ..) |
| exact sum_le_sum fun i hi=>sum_le_sum fun j hj=>mul_le_mul_of_nonneg_left (h i hi j hj) |
| (mul_nonneg (pct_pos (NeZero.pos _) _).le (pct_pos (NeZero.pos _) _).le) |
| lemma vtest {f g : Paint n} (h:∀ i∈d.S,d.vm f i ≤ d.vm g i) : d.vi f≤d.vi g := by |
| rw [d.vpivot,d.vpivot]; refine mul_le_mul_of_nonneg_left ?_ (scaleM_nn ..) |
| exact sum_le_sum fun i hi=>mul_le_mul_of_nonneg_left (h i hi) (pct_pos (NeZero.pos _) _).le |
|
|
| lemma fnorm (f : Pics n) : d.ton (n:=n) (w:=0) (fun _=> d.fm f) ≤ d.ton f := by |
| apply (d.tm_le (d.tn0 _)).mpr |
| rw [d.ton_four] |
| apply d.ftest; intro i hi j hj |
| unfold fm Env.cond |
| rw [av_const]; apply av_four_le |
| lemma vnorm (f : Paint n) : d.von (n:=n) (w:=0) (fun _=> d.vm f) ≤ d.von f := by |
| apply (d.vm_le (d.vn0 _)).2 |
| rw [d.von_four] |
| apply d.vtest; intro i hi |
| unfold vm Env.cond; rw [av_const]; apply av_four_le |
|
|
| lemma froot {f g : Pics n} (hf:∀ s i j,0≤f s i j) (hg:∀ s i j,0≤g s i j) : |
| d.terr (n:=n) (w:=0) (fun _=>d.fm f) (fun _=>d.fm g) ≤ d.terr f g := by |
| unfold Axis.terr |
| apply (d.tm_le (d.tn0 _)).2 |
| rw [d.ton_four]; apply d.ftest; intro i hi j hj |
| unfold fm Env.cond |
| rw [av_const] |
| exact mixtures Meter.Avg _ _ (fun _=>hf ..) (fun _=>hg ..) |
|
|
| lemma fswap_det (f : Mat) (a : ℕ) : |
| pct n a * d.ti (n:=n) (w:=0) (fun _=>f) = pct n d.a * |
| (d.narrowed a).ti (n:=n) (w:=0) (fun _=>f) := by |
| rw [d.fpivot,fpivot,d.fdet,fdet] |
| dsimp only [narrowed] |
| rw [mul_left_comm (pct n a),mul_left_comm (pct n d.a)] |
| congr 1 |
| rw [mul_sum,mul_sum] |
| apply sum_congr rfl; intro i hi |
| rw [mul_sum,mul_sum]; apply sum_congr rfl; intro j hj; ring |
|
|
| end Axis |
|
|
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| section |
|
|
| set_option synthInstance.maxSize 4096 |
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis Hie At Finset |
|
|
| variable {n : ℕ} [Fact n.Prime] |
|
|
| lemma shrink {a b} (h:a≤b) : rate b/rate a=dry (b-a)^4 := by |
| have he : rate b=dry (b-a)^4*rate a := by |
| calc rate b=dry (b-a+a)^4 := by rw [Nat.sub_add_cancel h,rr] |
| _ = _ := by rw [dryP,rr,mul_pow] |
| rw [he,mul_div_cancel_right₀ _ (rate_pos _).ne'] |
| lemma swell {a b} (h:a≤b) : rate a/rate b=box (b-a)^4 := by |
| rw [← inv_div (rate b),shrink h,dry,inv_pow] |
| simp |
| lemma odds {a b n} (hp: 2^b≤n) (h:a≤b) : |
| pct n a / pct n b ≤ (2*box (b-a))^4 := by |
| have he:= (pct_bounds hp).1 |
| have ha:= (pct_bounds (k:=a) (le_trans (Nat.pow_le_pow_right (by omega) h) hp)).2 |
| calc _ ≤ (16*rate a)/rate b := by |
| gcongr |
| · have hh:= rate_pos a |
| positivity |
| · exact rate_pos _ |
| _ = _:= by rw [mul_div_assoc,swell h]; ring |
|
|
| abbrev nar (a k : ℕ) := max a k |
| def salary (a k : ℕ) := if k≤a then box (a-k) else dry (k-a)^3 |
| def loaded (n a k : ℕ) := rate k/rate a*(pct n a/pct n (nar a k)) |
| def distn (a b : ℕ) := (a-b)+(b-a) |
| lemma paypos (a k) : 0<salary a k := by |
| unfold salary; split |
| · exact box0 _ |
| exact pow_pos (dry0 _) _ |
| lemma coarse_pay {a k} (h:k≤a) : |
| loaded n a k=box (a-k)^4 := by |
| unfold loaded nar; rw [max_eq_left h,swell h,div_self (pct_pos (NeZero.pos _) _).ne',mul_one] |
| lemma cost_pos (n : ℕ) [Fact n.Prime] (a k) : 0<loaded n a k := |
| mul_pos (div_pos (rate_pos _) (rate_pos _)) |
| (div_pos (pct_pos (NeZero.pos _) _) (pct_pos (NeZero.pos _) _)) |
|
|
| lemma burden {k a} (hp: 2^(nar a k)≤n) : |
| loaded n a k ≤ 16 * box (4*distn a k) := by |
| let l:=nar a k |
| rcases le_total k a with h|h |
| · rw [coarse_pay h,distn, Nat.sub_eq_zero_of_le h,Nat.add_zero,Nat.mul_comm,boxM] |
| have := box_one (a-k) |
| nlinarith [show 0≤box (a-k)^4 by positivity] |
| unfold loaded |
| rw [show nar a k=k from max_eq_right h,shrink h] |
| have hh : 2^k≤n:= by rwa [nar,max_eq_right h] at hp |
| refine le_trans (mul_le_mul_of_nonneg_left (odds hh h) (by positivity)) ?_ |
| have hu:=box_one (4*distn a k) |
| rw [← mul_pow,show dry (k-a)*(2*box (k-a))=2 from ?_] |
| · linarith |
| rw [mul_left_comm,reunite,mul_one] |
|
|
| /-- uniformly bounded, in roots -/ |
| def RCap (K : ℝ) (f : Pics n) := ∀ s i j,0≤ f s i j ∧ fourth (f s i j) ≤ K |
|
|
| omit [Fact (Nat.Prime n)] in |
| lemma from_cap {K : ℝ} {f : Pics n} (h:RCap K f) s i j : |
| 0≤f s i j ∧ f s i j≤K^4 := by |
| obtain ⟨hh,he⟩:=h s i j |
| exact ⟨hh,le_trans (le_of_eq (fourth_four hh).symm) (pow_le_pow_left₀ (fourth_nn _) he _)⟩ |
|
|
| namespace Axis |
| variable (d : Axis) |
| def carry (k : ℕ) (f : Pics n) : Pics n := |
| fun s i j=> loaded n d.a k*f s i j |
|
|
| def pinned (a : ℕ) (f : Pics n) := d.wmask a f=f |
|
|
| lemma ton_subnorm (f : Pics n) : d.ton (fun s i j=> |f s i j|)=d.ton f := Meter.Labs .. |
| lemma ton_ext {f g : Pics n} |
| (h:∀ s i j, i∈src d.S d.u s → j∈dst d.S d.a s → f s i j=g s i j) : |
| d.ton f=d.ton g := by |
| have he1 : d.ton f ≤ d.ton g := by |
| rw [← d.ton_subnorm g]; exact d.torder fun s i j he hg=>by rw [h s i j he hg] |
| have he2 : d.ton g≤d.ton f := by |
| rw [← d.ton_subnorm f]; exact d.torder fun s i j he hg=>by rw [h s i j he hg] |
| exact le_antisymm he1 he2 |
|
|
| lemma root_fee {f g : Pics n} {K} (h:RCap K f) (e:RCap K g) (hp : 1≤K) : |
| d.ton (fun s i j=> f s i j-g s i j) ≤4*K^3*d.terr f g := by |
| let a : Pics n := fun s i j=> fourth (f s i j)-fourth (g s i j) |
| have hz : 0≤4*K^3 := by positivity |
| change _≤4*K^3*d.ton a |
| rw [← d.ton_subnorm a,← abs_of_nonneg hz,← d.tscale] |
| refine d.torder fun s i j hv hh=>?_ |
| obtain ⟨h1,h2⟩:=h s i j; obtain ⟨h3,h4⟩:=e s i j |
| exact ordinary h1 h3 h2 h4 |
|
|
| lemma unit_change {a : ℕ} (h : d.a≤a) (hp : 2^a≤n) (f : Mat) : |
| d.ton (n:=n) (w:=0) (fun _=>f) ≤ |
| 2*box (a-d.a) * (narrowed d a).ton (n:=n) (w:=0) (fun _=>f) := by |
| let K:= 2*box (a-d.a) |
| have he : 0≤K := mul_nonneg (by norm_num) (box0 _).le |
| change _ ≤ K * _ |
| apply (d.tm_le (mul_nonneg he ((d.narrowed a).tn0 _))).2 |
| rw [mul_pow, ton_four] |
| exact le_of_mul_le_mul_left (a:= pct n a) (by |
| let g:Mat:=fun i j=> f i j^4 |
| have hz := d.fswap_det (n:=n) g a |
| change pct n a*d.ti (n:=n) (w:=0) (fun _=>g) ≤ pct n a*(K^4*(narrowed d a).ti (n:=n) (w:=0) (fun _=>g)) |
| rw [hz,← mul_assoc] |
| have ho:pct n d.a ≤ pct n a *K^4 := by rw [mul_comm]; exact (div_le_iff₀ (pct_pos (NeZero.pos n) _)).1 (odds hp h) |
| exact mul_le_mul_of_nonneg_right ho ((d.narrowed a).ti_nn (fun _ _ _ _ _=>by unfold g; positivity))) |
| (pct_pos (NeZero.pos n) _) |
|
|
| lemma mean_move {a : ℕ} (h : d.a≤a) {f : Pics n} (e:d.pinned a f) i {j} (hj:j∈d.S) : |
| (pct n d.a/pct n a) * d.fm f i j = (d.narrowed a).fm f i j := by |
| have hp:= d.ite_wmask h f hj (i:=i); unfold pinned at e; rw [e] at hp |
| field_simp [(pct_pos (NeZero.pos n) a).ne'] |
| linarith |
|
|
| lemma carry_change (k) {f:Pics n} (h:d.pinned (nar d.a k) f) (i) {j} |
| (hj:j∈d.S) : |
| d.fm (d.carry k f) i j=rate k/rate d.a*(d.narrowed (nar d.a k)).fm f i j := by |
| unfold carry |
| rw [d.fscalar,loaded,mul_assoc,d.mean_move (le_max_left ..) h i hj] |
|
|
| abbrev paycheck (K : ℝ) := 64*K^4 |
|
|
| set_option maxHeartbeats 700000 in |
| /-- Comparison of one conditioned first-channel contribution. -/ |
| lemma stream_fee {k : ℕ} (hp: 2^(nar d.a k)≤n) {K : ℝ} (hK:1≤K) {f g : Pics n} |
| (hf:RCap K f) (hg:RCap K g) |
| (hf':d.pinned (nar d.a k) f) (hg':d.pinned (nar d.a k) g) |
| {D : Mat} (hD:∀ i∈d.S,∀ j∈d.S, 0≤D i j) |
| (hb:∀ i∈d.S,∀ j∈d.S,d.fm (d.carry k f) i j≤K*D i j) : |
| d.ton (n:=n) (w:=0) (fun _ i j=> rel (d.fm (d.carry k f) i j- |
| d.fm (d.carry k g) i j) (D i j)) |
| ≤ paycheck K * salary d.a k * (d.narrowed (nar d.a k)).terr f g := by |
| let v (i j) := d.fm (d.carry k f) i j-d.fm (d.carry k g) i j |
| have hl (i) (hi : i∈d.S) (j) (hj:j∈d.S) : 0≤rel (v i j) (D i j) := by |
| unfold rel; have h:=hD i hi j hj; positivity |
| have hk : 0<K := by linarith |
| by_cases hu : k≤d.a |
| · rw [nar,max_eq_left hu,salary,ite_eq_left hu] |
| let p:= box (d.a-k) |
| let e (i j):= fourth (d.fm f i j)-fourth (d.fm g i j) |
| let a :=32*K*p |
| have hp': 0<p:=box0 _ |
| have hA : 0≤a:=by unfold a; positivity |
| have he (s i j) (h: i∈src d.S d.u (s:Pool n)) (h1:j∈dst d.S d.a s) : |
| |rel (v i j) (D i j)|≤ a * |e i j| := by |
| have he2:= (mem_filter.1 h).1; have he3:= (mem_filter.1 h1).1 |
| rw [abs_of_nonneg (hl _ he2 _ he3)] |
| have Hv (g:Pics n): d.fm (d.carry k g) i j=p^4*d.fm g i j := by |
| unfold carry; rw [d.fscalar,coarse_pay hu] |
| have Ha : 0 ≤ d.fm f i j := (d.goodfm (fun s h h'=>from_cap hf s i j)).1 |
| have Hb : 0 ≤ d.fm g i j := (d.goodfm (fun s h h'=>from_cap hg s i j)).1 |
| have H2 := hb i he2 j he3 |
| unfold v; rw [Hv,Hv]; rw [Hv] at H2 |
| have hw : 0≤p^4:=by positivity |
| apply le_trans (fidelity (mul_nonneg hw Ha) (mul_nonneg hw Hb) (hD i he2 j he3) H2 hK) |
| rw [fourth_mul hw,fourth_mul hw,four_fourth hp'.le,← mul_sub,abs_mul,abs_of_nonneg hp'.le] |
| unfold a e; exact le_of_eq (by ring) |
| refine (d.torder he).trans ?_ |
|
|
| rw [d.tscale,d.ton_subnorm (f:=fun s i j=> e i j), abs_of_nonneg hA] |
| have hs : d.narrowed d.a=d := rfl |
| rw [hs] |
| have hd: d.ton (n:=n) (w:=0) (fun _ i j=> e i j)≤ d.terr f g := |
| d.froot (fun s i j=>(hf s i j).1) (fun s i j=>(hg s i j).1) |
| refine mul_le_mul (by |
| change 32*K*p ≤ 64*K^4*p |
| have hC : K≤K^4 := by simpa using pow_le_pow_right₀ hK (show 1≤ (4:ℕ) by omega) |
| exact mul_le_mul_of_nonneg_right (by linarith) hp'.le) hd (d.tn0 _) |
| (by unfold paycheck; have h:=box0 (d.a-k); positivity) |
| have ht:=lt_of_not_ge hu |
| have ha := show nar d.a k=k from max_eq_right ht.le |
| let p:=dry (k-d.a) |
| have hv (i j) (hj:j∈d.S) : |
| v i j=p^4*(d.narrowed k).fm (fun s i j=>f s i j-g s i j) i j := by |
| unfold v; rw [carry_change _ k hf' _ hj,carry_change _ k hg' _ hj,ha,←mul_sub,fmean_sub,shrink ht.le] |
| let A : Mat := fun i j=> (d.narrowed k).fm (fun s i j=> f s i j-g s i j) i j |
| have he (s i j) (hi:i∈src d.S d.u (s:Pool n)) (hj:j∈dst d.S d.a s) : |
| |rel (v i j) (D i j)| ≤ p^4 * |A i j| := by |
| have hx := (mem_filter.1 hi).1; have hy:=(mem_filter.1 hj).1 |
| have h0:=hD i hx j hy |
| rw [abs_of_nonneg (hl _ hx _ hy)] |
| unfold rel |
| apply le_trans (min_le_right ..) |
| have hh : 0≤ p^4:=by positivity |
| rw [div_le_iff₀ (by linarith)] |
| rw [hv i j hy,abs_mul,abs_of_nonneg hh] |
| change p^4* |A i j| ≤ _ |
| nlinarith [show 0 ≤ p^4 * |A i j| from by positivity] |
| apply (d.torder he).trans |
| rw [d.tscale,d.ton_subnorm (f:=fun s i j=> A i j),abs_of_nonneg (by positivity)] |
| rw [ha] at hp ⊢ |
| have hd := (d.narrowed k).fnorm (fun s i j=> f s i j-g s i j) |
| have hx := (d.narrowed k).root_fee hf hg hK |
| change (d.narrowed k).ton (w:=0) (n:=n) (fun _=> A) ≤ _ at hd |
| have hf1 := le_trans hd hx |
| apply le_trans (mul_le_mul_of_nonneg_left (d.unit_change (n:=n) ht.le hp A) (by positivity)) |
| apply le_trans (mul_le_mul_of_nonneg_left |
| (mul_le_mul_of_nonneg_left hf1 (show 0≤2*box (k-d.a) from mul_nonneg (by norm_num) (box0 _).le)) |
| (by positivity)) |
| rw [salary,ite_eq_right hu] |
| have hg : p*box (k-d.a)=1:=reunite _ |
| let w:=(d.narrowed k).terr f g |
| change p^4 * (2 * box (k-d.a) * (4*K^3*w)) ≤ _*p^3*w |
| unfold paycheck |
| have he : K^3≤K^4:=pow_le_pow_right₀ hK (by omega) |
| have hp0 : 0 ≤ p:= (dry0 _).le |
| have hw : 0≤w:= (d.narrowed k).tn0 _ |
| calc _ = 8*K^3*p^3*w*(p*box (k-d.a)) := by ring |
| _ ≤ _ := by |
| rw [hg,mul_one] |
| have hk:=mul_le_mul_of_nonneg_right (show 8*K^3≤64*K^4 from by linarith [show 0≤K^4 by positivity]) |
| (show 0 ≤ p^3*w by positivity) |
| linarith |
|
|
| lemma realize_pin {a : ℕ} {f : Pics n} |
| (h:∀ s i j,f s i j≠0 → j∈dst d.S a s) : d.pinned a f := by |
| unfold pinned wmask; ext s i j; split |
| · rfl |
| · next he=> exact Eq.symm (not_not.mp (fun e=>he (h _ _ _ e))) |
|
|
| lemma raw_fee {k : ℕ} (hp: 2^(nar d.a k)≤n) {K : ℝ} (hK:1≤K) {f g : Pics n} |
| (hf:RCap K f) (hg:RCap K g) (hf':d.pinned (nar d.a k) f) (hg':d.pinned (nar d.a k) g) : |
| d.ton (fun s i j=> d.carry k f s i j-d.carry k g s i j) ≤ |
| paycheck K*box (4*distn d.a k)*(d.narrowed (nar d.a k)).terr f g := by |
| let c:=loaded n d.a k; let a:=nar d.a k |
| let z:Pics n:=fun s i j=>f s i j-g s i j |
| have he : d.pinned a z:= by |
| have ht:d.wmask a z= fun s i j=> d.wmask a f s i j-d.wmask a g s i j := by |
| unfold wmask z; ext s i j; split <;> simp_all |
| unfold pinned; rw [ht,show d.wmask a f=f from hf',show d.wmask a g=g from hg'] |
| have hw : d.ton z=(d.narrowed a).ton z := by conv_lhs=>rw [← show d.wmask a z=z from he] |
| exact d.tmask a (le_max_left ..) z |
| have hx := (d.narrowed a).root_fee hf hg hK |
| change d.ton (fun s i j=> c*f s i j-c*g s i j) ≤ _ |
| simp_rw [← mul_sub]; rw [d.tscale]; change |c| * d.ton z ≤ _ |
| have hc : 0≤c := (cost_pos n _ _).le |
| rw [abs_of_nonneg hc,hw] |
| refine le_trans (mul_le_mul_of_nonneg_left hx hc) ?_ |
| let b:=box (4*distn d.a k) |
| have hu : c≤16*b := burden hp |
| have hk : 0≤K := by linarith |
| have hv :=(d.narrowed a).tn0 (n:=n) (w:=0) (fun s i j=>fourth (f s i j)-fourth (g s i j)) |
| have hb : 0≤b := (box0 _).le |
| rw [← mul_assoc]; apply mul_le_mul_of_nonneg_right _ hv |
| apply le_trans (mul_le_mul_of_nonneg_right hu (show 0≤4*K^3 by positivity)) |
| unfold paycheck |
| change _ ≤ _ * b |
| have hz : K^3 ≤ K^4 := pow_le_pow_right₀ hK (by omega) |
| nlinarith |
|
|
| set_option maxHeartbeats 600000 in |
| /-- One collective loss of a wholly fine tail. X/rate d.a are the raw units. -/ |
| lemma fine_tail {X0 : Mat} {K : ℝ} {m : ℕ} |
| (hK:1≤K) (hp : 2^d.a ≤ n) (hv : 2^d.u ≤ n) |
| (hC:d.S.card≤d.N) |
| (he:∀ i∈d.S,∀ j∈d.S,0≤X0 i j ∧ X0 i j ≤ K*rate (d.a+m)) |
| (hr:∀ i∈d.S,∑ j∈d.S,X0 i j ≤ K) : |
| d.ton (n:=n) (w:=0) (fun _ i j=> X0 i j / rate d.a) ≤ 4*K*dry m^3 := by |
| let f:=rate d.a; let g:=rate d.u; let a:=dry m |
| have hf : 0<f:=rate_pos _ |
| have hg : 0<g:=rate_pos _ |
| have ha : 0≤a:= (dry0 _).le |
| have hk : 0≤K:=by linarith |
| have he2 : rate (d.a+m) = a^4*f := by rw [rr,dryP,mul_pow,mul_comm]; rfl |
| let T:Mat:=fun i j=> (X0 i j/f)^4 |
| have H (i) (h:i∈d.S) : |
| (∑ j∈d.S,T i j) ≤ K^4*(a^3)^4/f := by |
| have hl (j) (hj:j∈d.S) : |
| T i j≤ (K*a^4)^3 * (X0 i j/f) := by |
| obtain ⟨h1,h2⟩:= he i h j hj |
| have hh : X0 i j/f ≤ K*a^4 := by |
| rw [div_le_iff₀ hf] |
| rw [he2] at h2; linarith |
| have he : 0≤X0 i j/f := div_nonneg h1 hf.le |
| unfold T |
| rw [pow_succ] |
| exact mul_le_mul_of_nonneg_right (pow_le_pow_left₀ he hh 3) he |
| apply le_trans (sum_le_sum hl) |
| rw [← mul_sum, ← sum_div] |
| apply le_trans (mul_le_mul_of_nonneg_left (div_le_div_of_nonneg_right (hr i h) hf.le) |
| (show 0≤(K*a^4)^3 by positivity)) |
| exact le_of_eq (by ring) |
| apply (d.tm_le (n:=n) (w:=0) (c:=4*K*a^3) (by positivity)).mpr |
| change d.ti (fun (_:Pool n)=> T) ≤ (4*K*a^3)^4 |
| rw [d.fpivot,d.fdet] |
| have hz : 0 ≤ pct n d.u*pct n d.a := mul_nonneg (pct_pos (NeZero.pos _) _).le (pct_pos (NeZero.pos _) _).le |
| have hz' : pct n d.u*pct n d.a ≤16*g*(16*f) := |
| mul_le_mul (pct_bounds hv).2 (pct_bounds hp).2 (pct_pos (NeZero.pos _) _).le (by positivity) |
| have h1 (i) (hi:i∈d.S) : |
| ∑ j∈d.S,pct n d.u*pct n d.a*T i j ≤ (4*K*a^3)^4 *g := by |
| rw [← mul_sum] |
| have hT := H i hi |
| apply le_trans (mul_le_mul hz' hT (by unfold T; apply sum_nonneg; intros; positivity) (by positivity)) |
| exact le_of_eq (by field_simp; ring) |
| apply le_trans (mul_le_mul_of_nonneg_left (sum_le_sum h1) (scaleM_nn _ _)) |
| simp only [sum_const,nsmul_eq_mul] |
| obtain hn|hn:=Nat.eq_zero_or_pos d.N |
| · unfold scaleM; rw [hn]; simp; positivity |
| unfold scaleM; change ((d.N:ℝ)*g)⁻¹ * _ ≤_ |
| have he0 : 0 < (d.N:ℝ)*g:=mul_pos (by exact_mod_cast hn) hg |
| have he1 : (d.S.card:ℝ)≤ d.N:=by exact_mod_cast hC |
| rw [← div_eq_inv_mul,div_le_iff₀ he0] |
| have hl := mul_le_mul_of_nonneg_right he1 (show 0≤(4*K*a^3)^4*g by positivity) |
| linarith |
|
|
| end Axis |
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| section |
|
|
| set_option synthInstance.maxSize 4096 |
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis Hie At Finset Affine Square |
|
|
| variable {n : ℕ} [Fact n.Prime] |
|
|
| private instance s_one : Subsingleton (Salt 0) := inferInstanceAs (Subsingleton (V 1)) |
| private lemma empty_seam (x y : ZMod n) (k j) (s : Env.Slice n k j 0) : |
| (@Env.exportP n 0 0 _ k j x y le_rfl 0 s) = Env.outward k j x y s := by |
| unfold Env.exportP; congr 1 |
| cases s with |
| | mk a s => |
| cases s with |
| | mk b s=> |
| cases s with |
| | mk c p=> |
| apply Prod.ext |
| · rfl |
| apply Prod.ext |
| · rfl |
| apply Prod.ext |
| · rfl |
| exact Subsingleton.elim .. |
|
|
| def ebb := 1-loss Env.Choice (10*gap0) |
| lemma ebb_nn : 0<ebb ∧ ebb<1 := by |
| have h : 1≤10*gap0 := by linarith [gapFuel_pos] |
| obtain ⟨h,h1⟩ := loss_bounds (γ:=Env.Choice) h |
| unfold ebb; constructor <;> linarith |
| /-- lam = walk length per unit statistical slack. -/ |
| def Wind (e lam : ℕ) : Prop := ebb^lam*16≤dry e^4 |
| lemma find_lam (e : ℕ) : ∃ lam, Wind e lam := by |
| have he : 0 < dry e ^4 /16 := div_pos (pow_pos (dry0 _) _) (by norm_num) |
| obtain ⟨l,hl⟩ := exists_pow_lt_of_lt_one he ebb_nn.2 |
| exact ⟨l,by unfold Wind; linarith⟩ |
| lemma blow {e lam} (h:Wind e lam) {a : ℕ} (he:0<a) : |
| ebb^(lam*a)*16 ≤dry (e*a)^4 := by |
| have hz := pow_le_pow_left₀ (show 0≤ebb^lam*16 by have :=ebb_nn.1; positivity) h a |
| rw [pow_mul,dryM] |
| unfold Wind at h |
| apply le_trans (b:=(ebb^lam*16)^a) ?_ |
| · exact hz.trans_eq (by rw [← pow_mul,← pow_mul,mul_comm a]) |
| · rw [mul_pow] |
| have hx : (16:ℝ)≤16^a := calc |
| _ = (16:ℝ)^1 := by ring |
| _ ≤ _ := pow_le_pow_right₀ (by norm_num) he |
| exact mul_le_mul_of_nonneg_left hx (pow_nonneg (pow_nonneg ebb_nn.1.le _) _) |
|
|
| lemma blows {e lam} (h:Wind e lam) {a : ℕ} (he:0<a) (k j) (x y : ZMod n) (f : Pool n→ℝ) : |
| Env.cond k j x y (fun s=> (Env.sampling k j x y (d:=0) (w:=0) le_rfl (lam*a) f s- |
| Env.cond k j x y f)^4) ≤ |
| dry (e*a)^4 * Env.cond k j x y (fun s=>f s^4) := by |
| have hx:= @Env.sampler_est n 0 0 _ k j x y le_rfl 0 (lam*a) f |
| let o:= Env.outward k j x y (w:=0) |
| have hs (s:Env.Slice n k j 0) : |
| @Env.panel n 0 0 _ k j x y le_rfl 0 f s=f (o s) := by |
| change f (_:_)=_ |
| exact congrArg f (empty_seam x y k j s) |
| dsimp only at hx |
| unfold mass4 at hx |
| simp_rw [hs,empty_seam x y k j] at hx |
| rw [show @Env.panel n 0 0 _ _ _ x y le_rfl 0 f=(fun i=>f (o i)) from funext hs] at hx |
| unfold Env.cond |
| apply le_trans hx |
| have hv : 0≤ av (fun s:Env.Slice n k j 0=> f (o s)^4) := av_nonneg _ fun _ => by positivity |
| rw [← mul_assoc] |
| exact mul_le_mul_of_nonneg_right (blow h he) hv |
|
|
| namespace Axis |
| variable (d:Axis) |
|
|
| def fluke (l : ℕ) (f : Pics n) : Pics n := |
| fun s i j=> d.fw l f s i j - d.fm f i j |
| def vluke (l : ℕ) (f : Paint n) : Paint n := |
| fun s i=>d.vw l f s i - d.vm f i |
|
|
| lemma windF {e lam} (h:Wind e lam) {a:ℕ} (he:0<a) (f:Pics n) : |
| d.ton (d.fluke (lam*a) f) ≤ dry (e*a)*d.ton f := by |
| apply (d.tm_le (mul_nonneg (dry0 _).le (d.tn0 f))).2 |
| rw [mul_pow,d.ton_four,← d.tmul] |
| apply d.ftest; intro i hi j hj |
| rw [d.fscalar] |
| exact blows h he _ _ _ _ (fun s=> f s i j) |
|
|
| lemma windV {e lam} (h:Wind e lam) {a:ℕ} (he:0<a) (f:Paint n) : |
| d.von (d.vluke (lam*a) f) ≤ dry (e*a)*d.von f := by |
| apply (d.vm_le (mul_nonneg (dry0 _).le (d.vn0 f))).2 |
| rw [mul_pow,d.von_four,← d.vmul] |
| apply d.vtest; intro i hi |
| unfold vm Env.cond; rw [av_cmul] |
| exact blows h he _ _ _ _ (fun s=>f s i) |
|
|
| end Axis |
|
|
| private lemma into_range {p q : ℝ} {α γ : Type} [Fintype α] [Nonempty α] [Fintype γ] [Nonempty γ] |
| (G : Family γ α) {f : α→ℝ} (h:∀ x,p≤f x∧f x≤q) (l x) : |
| p≤walk G f l x∧walk G f l x≤q := by |
| induction l generalizing x with |
| | zero=>exact h x |
| | succ l ih=> |
| let w:=walk G f l |
| have hh (j:γ) : p≤(w (G j x)+w x)/2∧(w (G j x)+w x)/2≤q := by |
| obtain ⟨hp,he⟩:=ih x |
| obtain ⟨hs,ht⟩:=ih (G j x) |
| unfold w; constructor <;> linarith |
| change p≤av _∧av _ ≤ q |
| refine ⟨le_trans (le_of_eq (av_const (α:=γ) p).symm) (av_mono fun i=> (hh i).1), |
| le_trans (av_mono fun i=>(hh i).2) (le_of_eq (av_const (α:=γ) q))⟩ |
|
|
| lemma magnitude {p q : ℝ} (x y : ZMod n) (k j l) {f:Pool n→ℝ} |
| (h:∀ s,Env.mask k j x y s → p≤f s∧ f s≤q) {s} |
| (hs:Env.mask k j x y s) : |
| p≤@Env.sampling n 0 0 _ k j x y le_rfl l f s∧ |
| @Env.sampling n 0 0 _ k j x y le_rfl l f s ≤q := by |
| let t:=Env.inward k j x y s |
| let w:=@Env.exportP n 0 0 _ k j x y le_rfl 0 |
| have he : w t=s:= Eq.trans (empty_seam x y k j t) (Env.inverse1 _ _ _ _ _ hs) |
| have hu:= @Env.sampler_identity n 0 0 _ k j x y le_rfl 0 l f t |
| have hz (u) : p≤ f (w u)∧ f (w u)≤q := h _ (Env.hits ..) |
| change @Env.sampling n 0 0 _ _ _ _ _ _ _ _ (w t) = walk _ _ _ _ at hu |
| rw [he] at hu; rw [hu] |
| exact into_range _ hz l t |
|
|
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis Hie At Finset |
|
|
| structure StepKey where |
| a : ℕ |
| u : ℕ |
| r : ℕ |
|
|
| def allowance (A M : ℕ) (t : StepKey) : ℝ := |
| dry (M / 8) * box (2*t.a+2*t.u+A*t.r) |
| def active (A M : ℕ) (t : StepKey) := 2*t.a+2*t.u+A*t.r < M / 8 |
|
|
| namespace StepKey |
| variable (t : StepKey) |
|
|
| def allowanceStep (A m k : ℕ) := allowance A m ⟨k,t.u,t.r-1⟩ |
| def token (A M : ℕ) := allowance A M t * dry A |
| lemma allow_p (A M) : 0< allowance A M t := mul_pos (dry0 _) (box0 _) |
| lemma token_p (A M) : 0<t.token A M:=mul_pos (t.allow_p ..) (dry0 _) |
|
|
| lemma inactive {A M} (h:¬active A M t) : 1 ≤ allowance A M t := by |
| unfold allowance |
| have he := reunite (M/8) |
| apply he.symm.le.trans (mul_le_mul_of_nonneg_left (box_mono (le_of_not_gt h)) (dry0 _).le) |
|
|
| lemma lower (k : ℕ) {v : StepKey} {B : ℕ} (hv : v.r<t.r) (ha:v.a≤ k+B) |
| (hu:v.u≤t.u) (A m) : |
| box (t.u-v.u)*allowance A m v ≤ box (2*B)*t.allowanceStep A m k := by |
| unfold allowance allowanceStep allowance |
| rw [mul_left_comm (box (t.u-v.u)),mul_left_comm (box (2*B)),← boxP,← boxP] |
| apply mul_le_mul_of_nonneg_left (box_mono ?_) (dry0 _).le |
| simp only |
| have he:=Nat.mul_le_mul_left A (show v.r≤ t.r-1 by omega) |
| omega |
|
|
| lemma budget_gap {M m} (h:m≤M) : dry (m/8)=dry (M/8)*box (M/8-m/8) := by |
| let a:=m/8; let b:=M/8 |
| have hz:b=b-a+a:=by dsimp [a,b]; omega |
| calc _ = dry (b-a+a)*box (b-a) := by |
| rw [dryP,mul_comm (dry _*_),← mul_assoc,unify, one_mul] |
| _ = _ := by change dry (b-a+a)*_=dry b*box _; congr 2; omega |
|
|
| lemma transfer {M m} (A k) (h:m≤M) (hp:0<t.r) : |
| t.allowanceStep A m k=box (M/8-m/8) * ({t with a:=k}:StepKey).token A M := by |
| unfold allowanceStep token allowance |
| let a:=A*(t.r-1) |
| have hv: A*t.r=a+A := by dsimp only [a]; rw [← Nat.mul_succ]; congr 1; omega |
| dsimp only |
| rw [budget_gap h,hv,← add_assoc,boxP (2*k+2*t.u+a) A]; change _ * box (2*k+2*t.u+a) = _ |
| rw [mul_assoc (dry _) (box _*box _) (dry A),mul_assoc (box _),unify,mul_one]; ring |
|
|
| lemma adjust (a k v) : |
| salary a k * box (2*k+v) = dry (distn a k)*box (2*a+v) := by |
| unfold salary distn; split |
| · next h=> |
| rw [show k-a=0 by omega,add_zero,← boxP] |
| let d:=a-k |
| have hh : 2*a+v=d+(d+(2*k+v)) := by dsimp [d]; omega |
| rw [hh,boxP d (d+(2*k+v)),← mul_assoc,reunite,one_mul] |
| · next h=> |
| rw [show a-k=0 by omega,zero_add] |
| let d:=k-a |
| change dry d^3*_=dry d*_ |
| have hs : 2*k+v=d+d+(2*a+v):=by dsimp [d]; omega |
| rw [hs,boxP,boxP]; rw [show dry d^3*(box d * box d * box (2*a+v))= |
| dry d*box (2*a+v)*(dry d*box d)*(dry d*box d) from by ring,reunite]; ring |
|
|
| lemma divide {m M A} {k d} (h:m≤M) (he:M-m ≤ d+distn t.a k+1) (hp:1≤d) (hr:0<t.r) : |
| salary t.a k*t.allowanceStep A m k ≤ |
| t.token A M * box (2*d) * dry (distn t.a k/2) := by |
| rw [transfer t A _ h hr] |
| have hz := adjust t.a k (2*t.u+A*t.r) |
| simp only [← add_assoc] at hz |
| let e:=distn t.a k |
| change salary _ _ *_ ≤ t.token A M * box (2*d)*dry (e/2) |
| calc |
| _ = t.token A M * (box (M/8-m/8)*dry e) := by |
| unfold token allowance |
| dsimp only |
| unfold e |
| have he := congrArg (fun x=> (dry (M/8)*box (M/8-m/8)*dry A)*x) hz |
| linear_combination he |
| _ ≤ _ := by |
| rw [mul_assoc] |
| apply mul_le_mul_of_nonneg_left _ (t.token_p ..).le |
| have he : M/8 - m/8 + e/2 ≤ 2*d + e := by dsimp [e]; omega |
| have ht :=box_mono he |
| rw [boxP,boxP] at ht |
| let b:=box e; let c:=box (e/2) |
| unfold dry |
| rw [← div_eq_mul_inv,← div_eq_mul_inv, div_le_div_iff₀ (box0 _) (box0 _)] |
| exact ht |
|
|
| lemma raw_pay {m M A} {k s} (h:m≤M) (he1:distn t.a k<s) (he:M-m≤ s+1) (hp:0<t.r) : |
| box (4*distn t.a k)*t.allowanceStep A m k ≤ |
| t.token A M*box (8*s)*dry (distn t.a k/2) := by |
| rw [transfer t A _ h hp] |
| unfold token allowance |
| dsimp only |
| let d:=distn t.a k |
| have hz : 4*d+(M/8-m/8)+(2*k+2*t.u+A*t.r)+d/2 ≤ |
| 8*s + (2*t.a+2*t.u+A*t.r) := by |
| dsimp only [d] at * |
| unfold distn at * |
| omega |
| have ht:= box_mono hz |
| rw [boxP _ (d/2),boxP _ (2*k+2*t.u+A*t.r),boxP _ (2*t.a+2*t.u+A*t.r), |
| boxP (4*d)] at ht |
| have hk:=mul_le_mul_of_nonneg_right ht (show 0≤dry (d/2) from (dry0 _).le) |
| have hh : box (4*d)*box (M/8-m/8) * box (2*k+2*t.u+A*t.r) ≤ |
| box (8*s)*box (2*t.a+2*t.u+A*t.r)*dry (d/2) := by |
| simpa only [mul_assoc,unify,mul_one] using hk |
| have he:=mul_le_mul_of_nonneg_right hh (mul_nonneg (dry0 (M/8)).le (dry0 A).le) |
| unfold d at he; linear_combination he |
|
|
| lemma unbias (A M) (h:0<t.r) : dry M ^3 ≤ t.token A M := by |
| have he:dry M≤dry (M/8) := dry_mono (by omega) |
| calc |
| _ ≤ dry M := by |
| have h1:= dry_one M; have h2:=dry0 M |
| exact le_trans (pow_le_pow_of_le_one h2.le h1 (show 1≤ (3:ℕ) by omega)) (by rw [pow_one]) |
| _ ≤ _ := he |
| _ ≤ _ := by |
| unfold token allowance |
| have hh : A≤2*t.a+2*t.u+A*t.r := by nlinarith |
| rw [mul_assoc] |
| have ht := mul_le_mul_of_nonneg_right (box_mono hh) (dry0 A).le |
| rw [unify] at ht |
| exact le_trans (le_of_eq (mul_one _).symm) (mul_le_mul_of_nonneg_left ht (dry0 _).le) |
| end StepKey |
|
|
| /-- coefficient remainders when summing all scale offsets/slack levels -/ |
| lemma breeze_charge (s d : ℕ) (h : d≤ s) : |
| box (8*s)* dry (18*s) ≤ dry (8*d)*dry s := by |
| rw [show 18*s=8*s+10*s by omega,dryP,← mul_assoc, unify,one_mul,← dryP] |
| exact dry_mono (by omega) |
|
|
| abbrev lull (a k : ℕ) := dry (distn a k/2) |
|
|
| lemma low_total (_ w : ℕ) : ∑ k∈range w,dry (k/2)≤4 := by |
| let p (k : ℕ) := ∑ i∈range k,dry (i/2) |
| have he (k : ℕ) : p (2*k)=2*∑ i∈range k,dry i := by |
| induction k with |
| | zero=>simp [p] |
| | succ k ih=> |
| unfold p |
| rw [show 2*(k+1)=2*k+1+1 by omega,sum_range_succ,sum_range_succ,sum_range_succ (n:=k)] |
| change p (2*k)+_+_ = _ |
| rw [ih,show 2*k/2=k by omega,show (2*k+1)/2=k by omega]; ring |
| apply le_trans (b:=p (2*w)) |
| · unfold p |
| exact sum_le_sum_of_subset_of_nonneg (range_mono (by omega)) fun i _ _=>(dry0 _).le |
| · rw [he]; linarith [thinSum (range w)] |
|
|
| lemma scale_total (F : Domain) (a) : ∑ k∈F,lull a k≤8 := by |
| classical |
| let T:=1+a+∑ k∈F,k |
| let p (k:ℕ) :=dry (k/2) |
| have ht (i) (h:i∈F) : i≤T := by |
| have he :=single_le_sum (f:=fun i:ℕ=>i) (fun _ _=>Nat.zero_le _) h |
| unfold T; omega |
| let U:=F.filter (fun i=>i≤a) |
| let V:=F.filter (fun i=>¬i≤a) |
| have H (F : Finset ℕ) (f : ℕ→ℕ) (he:∀ i∈F,f i≤T) |
| (hk:∀ i∈F,∀ j∈F,f i=f j → i=j) : |
| ∑ i∈F,p (f i)≤4 := by |
| rw [← sum_image (f:=p) (by intros i hi j hj; exact hk i hi j hj)] |
| apply le_trans (b:=∑ i∈range (T+1),p i) |
| · refine sum_le_sum_of_subset_of_nonneg ?_ (fun i _ _=>(dry0 _).le) |
| intro i hi |
| obtain ⟨j,hj,rfl⟩:=mem_image.mp hi |
| exact mem_range.2 (by have := he j hj; omega) |
| exact low_total 0 _ |
| have h1 : ∑ i∈U, lull a i ≤4 := by |
| apply le_trans (b:=∑ i∈U,p (a-i)) |
| · apply sum_le_sum |
| intro i hi; unfold p lull distn; rw [Nat.sub_eq_zero_of_le (mem_filter.1 hi).2,add_zero] |
| apply H |
| · intro i hi; unfold T; omega |
| intro i hi j hj e; obtain ⟨h1,h2⟩:=mem_filter.mp hi |
| obtain ⟨h3,h4⟩:=mem_filter.mp hj; omega |
| have h2 : ∑ i∈V, lull a i ≤4 := by |
| apply le_trans (b:=∑ i∈V,p (i-a)) |
| · apply sum_le_sum |
| intro i hi; unfold p lull distn; rw [Nat.sub_eq_zero_of_le (not_le.mp (mem_filter.1 hi).2).le,zero_add] |
| apply H |
| · intro i hi; exact le_trans (Nat.sub_le i a) (ht i (mem_filter.1 hi).1) |
| intro i hi j hj e; obtain ⟨h1,h2⟩:=mem_filter.mp hi; obtain ⟨h3,h4⟩:=mem_filter.mp hj |
| omega |
| have e := sum_filter_add_sum_filter_not F (fun i=>i≤a) (lull a) |
| rw [←e]; linarith |
|
|
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis Hie At Buf Finset |
|
|
| /-- Recipe-independent additive schedule. -/ |
| structure Stair where |
| M : ℕ |
| A : ℕ |
| key : StepKey |
| lam : ℕ |
|
|
| namespace Stair |
|
|
| variable (s : Stair) |
| def L := s.M.log2 + 1 |
| lemma length_pos : 0< s.L:= by unfold L; omega |
| def gap (i) := gapD s.L i |
| def cut (k) := distn s.key.a k+1 |
| /-- budget reached by group i. Difference indices m denote the paired |
| evaluation at m+1 and m. -/ |
| def reach (k i : ℕ) := s.M-max (s.gap i) (s.cut k) |
| def yoke (k : ℕ) : ℕ→ℕ |
| | 0=>0 |
| | i+1=>s.reach k i |
|
|
| def layers (k i : ℕ) := Ico (s.yoke k i) (s.reach k i) |
| def slack (m : ℕ) := s.M-(m+1) |
| def theta (L k : ℕ) := s.key.allowanceStep s.A L k |
| def wide := s.key.token s.A s.M |
|
|
| lemma wide_nn : 0 ≤ s.wide := (s.key.token_p ..).le |
| lemma theta_nn (m k) : 0 ≤ s.theta m k := (StepKey.allow_p ..).le |
| lemma last (i) : s.gap i=2^(s.L-1-i) := rfl |
| lemma reach_le (k i) : s.reach k i≤ s.M - s.cut k := by |
| unfold reach; omega |
| lemma reach_M (k i) : s.reach k i ≤ s.M := Nat.sub_le _ _ |
| lemma reach_loss (k i) : s.M-s.reach k i ≤ s.gap i+s.cut k := by unfold reach; omega |
| lemma under (k i) : s.yoke k i ≤ s.reach k i := by |
| cases i with |
| | zero => exact Nat.zero_le _ |
| | succ i=> |
| rw [yoke]; unfold reach |
| have he : s.gap (i+1) ≤ s.gap i := gapD_mono (show i≤ i+1 by omega) |
| omega |
|
|
| lemma precision (h : 0 < s.key.r) (k i) : |
| salary s.key.a k*s.theta (s.reach k i) k ≤ |
| s.wide*box (2*s.gap i)*lull s.key.a k := by |
| apply s.key.divide (s.reach_M k i) _ (gapD_pos ..) h |
| simpa only [gap,cut,← add_assoc] using s.reach_loss k i |
|
|
| lemma cheap {m k i} (he:m< s.reach k i) : |
| s.gap i ≤ s.slack m ∧ s.cut k ≤ s.slack m ∧ m+1< s.M := by |
| have hh : 1 ≤ s.gap i:= gapD_pos .. |
| unfold reach at he |
| unfold slack; omega |
|
|
| lemma full {k i m} (h : m∈s.layers k i) (hh:i< s.L) : |
| s.gap i≤ s.slack m ∧ s.slack m< 2*s.gap i := by |
| obtain ⟨ha,hb⟩:=mem_Ico.1 h |
| obtain ⟨hk,hl,ht⟩:=s.cheap hb |
| refine ⟨hk,?_⟩ |
| cases i with |
| | zero => |
| unfold gap gapD L |
| have he : s.M< 2^(s.M.log2+1):= Nat.lt_log2_self |
| rw [show s.M.log2+1-1-0=s.M.log2 by omega]; rw [pow_succ] at he |
| unfold slack; omega |
| | succ i=> |
| change s.reach k i≤ m at ha |
| have hx : s.gap i=s.gap (i+1)*2 := gapD_succ hh |
| unfold reach at ha hb |
| unfold slack; omega |
|
|
| lemma pegged {m k i} (h:0< s.key.r) (he:m< s.reach k i) {x} (hx:x=m ∨ x=m+1) : |
| box (4*distn s.key.a k)*s.theta x k ≤ |
| s.wide*box (8*s.slack m)*lull s.key.a k := by |
| obtain ⟨hc,hd,hm⟩:=s.cheap he |
| apply s.key.raw_pay (by omega) |
| · unfold cut at hd; omega |
| · unfold slack; omega |
| exact h |
|
|
| lemma slack_plan (i k) : |
| ∑ j∈range (s.reach k i),dry (s.slack j) ≤2 := by |
| rw [← sum_image (f:=dry)] |
| · apply thinSum |
| intro a ha b hb h; unfold slack at h |
| replace ha:=mem_range.1 ha; replace hb:=mem_range.1 hb |
| have he: a+1< s.M:=(s.cheap ha).2.2 |
| have hz: b+1< s.M:=(s.cheap hb).2.2 |
| omega |
|
|
| lemma union_sum (i k : ℕ) (f : ℕ→ℝ) : |
| ∑ j∈range (s.yoke k i),f j + ∑ j∈s.layers k i,f j = |
| ∑ j∈range (s.yoke k (i+1)),f j := by |
| change _ + ∑ j∈Ico (s.yoke k i) (s.reach k i),f j= ∑ j∈range (s.reach k i), f j |
| rw [sum_Ico_eq_sub f (s.under k i)]; ring |
|
|
| end Stair |
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| section |
|
|
| set_option synthInstance.maxSize 4096 |
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis Hie At Buf Finset |
|
|
| variable {n : ℕ} [Fact n.Prime] |
| def toll (b:Bool) (w d:ℝ) := if b then rel w d else |w| |
| lemma rel_nn {x d : ℝ} (h:0≤d) : 0≤ rel x d := by unfold rel; positivity |
| lemma toll_nn {b x d} (h:0≤d) : 0≤toll b x d := by unfold toll; split; exact rel_nn h; positivity |
| lemma rel_tip {x d:ℝ} (h:0≤d) : rel x d≤ |x| := by |
| apply le_trans (min_le_right ..) |
| rw [div_le_iff₀ (by linarith)] |
| nlinarith [abs_nonneg x] |
| lemma toll_tip {b x d} (h:0≤d) : toll b x d≤|x| := by unfold toll; split; exact rel_tip h; rfl |
| lemma rel_subadd {x y d : ℝ} (h:0≤d) : rel (x+y) d≤rel x d+rel y d := by |
| obtain h0:0<1+d:=by linarith |
| unfold rel |
| have hx : 0≤|x|/(1+d):=by positivity |
| have hy : 0≤|y|/(1+d):=by positivity |
| have hh := div_le_div_of_nonneg_right (abs_add_le x y) h0.le |
| rw [add_div] at hh; grind |
| lemma toll_add {b x y d} (h:0≤d) : toll b (x+y) d≤toll b x d+toll b y d := by |
| cases b |
| · exact abs_add_le _ _ |
| exact rel_subadd h |
| lemma toll_minus (b) (x d:ℝ) : toll b (-x) d=toll b x d := by simp [toll,rel] |
| lemma toll_sum {d : ℝ} {α : Type} (S : Finset α) (b : Bool) (h : 0≤d) (f : α→ℝ) : |
| toll b (∑ i∈S,f i) d≤∑ i∈S,toll b (f i) d := by |
| classical |
| induction S using Finset.induction_on with |
| | empty=>simp [toll,rel] |
| | @insert i S hi ih=> |
| rw [sum_insert hi,sum_insert hi]; exact le_trans (toll_add h) (add_le_add_right ih _) |
|
|
| structure Line (n : ℕ) where |
| seq : ℕ→ Pics n |
| account : Mat |
|
|
| namespace Line |
|
|
| variable (f : Line n) |
| def shake (m : ℕ) : Pics n:=fun s i j=> f.seq (m+1) s i j-f.seq m s i j |
| def pick (s : Stair) (d:Axis) (m) := d.fw (s.lam*s.slack m) (f.shake m) |
| def wear (s : Stair) (d : Axis) (m) := d.fluke (s.lam*s.slack m) (f.shake m) |
| def waveR (s : Stair) (d:Axis) (k i : ℕ) : Pics n := |
| fun u x y=> ∑ m∈ s.layers k i, f.pick s d m u x y |
| def weatherR (s : Stair) (d:Axis) (k i : ℕ) : Pics n := |
| fun u x y=> ∑ m∈range (s.yoke k i),f.wear s d m u x y |
|
|
| lemma zeroWeather (s k d u x y) : f.weatherR s d k 0 u x y=0 := by simp [weatherR,Stair.yoke] |
| lemma runoff (s : Stair) (d:Axis) (k i : ℕ) (hi:f.seq 0=fun _ _ _=>0) |
| (u x y) : |
| ∑ m∈range (s.yoke k i),f.pick s d m u x y= |
| f.weatherR s d k i u x y+d.fm (f.seq (s.yoke k i)) x y := by |
| have he (t) : ∑ m∈ range t,f.pick s d m u x y= |
| ∑ m∈range t,f.wear s d m u x y+d.fm (f.seq t) x y := by |
| induction t with |
| | zero=> rw [hi]; simp only [range_zero,sum_empty,zero_add] |
| simp [Axis.fm, Env.cond,av_zero] |
| | succ t ih=> |
| rw [sum_range_succ,sum_range_succ,ih,wear] |
| have hm : d.fm (f.shake t) x y=d.fm (f.seq (t+1)) x y-d.fm (f.seq t) x y:=d.fmean_sub .. |
| unfold Axis.fluke |
| rw [hm]; unfold pick; ring |
| exact he _ |
| lemma storm (s k d i u x y) : |
| f.weatherR s d k (i+1) u x y=f.weatherR s d k i u x y+ |
| ∑ m∈s.layers k i, f.wear s d m u x y := |
| Eq.symm (s.union_sum i _ _) |
|
|
| /-- Guarantees for one additive ray. -/ |
| structure Due (s : Stair) (k : ℕ) (d : Axis) (D : Mat) |
| (b : Bool) (c : ℝ) (f : Line n) : Prop where |
| pos : 0≤c |
| eve : f.seq 0=fun _ _ _=>0 |
| accuracy : ∀ m≤ s.M-s.cut k, d.ton (n:=n) (w:=0) |
| (fun _ i j=> toll b (d.fm (f.seq m) i j - f.account i j) (D i j)) |
| ≤ c * salary s.key.a k*s.theta m k |
| progress : ∀ m, m+1 ≤ s.M-s.cut k → d.ton (f.shake m) |
| ≤ c * box (4*distn s.key.a k)*(s.theta m k+s.theta (m+1) k) |
|
|
| lemma Due.enlarge {s : Stair} {k d D b c c'} {f:Line n} (h:Due s k d D b c f) |
| (he:c≤c') : Due s k d D b c' f := by |
| refine ⟨h.pos.trans he,h.eve,fun m e=>(h.accuracy _ e).trans ?_, |
| fun m e=>(h.progress _ e).trans ?_⟩ |
| · exact mul_le_mul_of_nonneg_right |
| (mul_le_mul_of_nonneg_right he (paypos ..).le) (s.theta_nn ..) |
| exact mul_le_mul_of_nonneg_right |
| (mul_le_mul_of_nonneg_right he (box0 _).le) |
| (add_nonneg (s.theta_nn ..) (s.theta_nn ..)) |
|
|
| lemma winning {s k d D b c} (h : Due s k d D b c f) (hr : 0< s.key.r) (i) : |
| d.ton (n:=n) (w:=0) |
| (fun _ x y=>toll b (d.fm (f.seq (s.reach k i)) x y-f.account x y) (D x y)) ≤ |
| c * s.wide * liftB 2 s.L i * lull s.key.a k := by |
| apply (h.accuracy _ (s.reach_le k i)).trans |
| have he := mul_le_mul_of_nonneg_left (s.precision hr k i) h.pos |
| unfold liftB; unfold Stair.gap at he; linarith |
|
|
| lemma foggy {s k d D b c} (h : Due s k d D b c f) (hw:Wind 18 s.lam) (hr:0< s.key.r) |
| (i) : |
| d.ton (f.weatherR s d k (i+1)) ≤ 4*c*s.wide*decay s.L i*lull s.key.a k := by |
| unfold weatherR |
| apply le_trans (d.tseries (fun m=>f.wear s d m) _) |
| let C:=2*c*s.wide *decay s.L i*lull s.key.a k |
| have h0:=h.pos |
| let u:=lull s.key.a k |
| have hu : 0≤u:=(dry0 _).le |
| have heC:0≤ C := by |
| have :=s.wide_nn |
| change 0≤2*c*s.wide*dry _*u; have hv:0≤dry (8*gapD s.L i):= (dry0 _).le |
| positivity |
| have he (m) (e:m< s.reach k i) : |
| d.ton (f.wear s d m) ≤ C*dry (s.slack m) := by |
| obtain ⟨h1,h2,h3⟩:= s.cheap e |
| let r:=s.slack m |
| have hs : 0<r:=lt_of_lt_of_le (gapD_pos ..) h1 |
| apply (d.windF hw hs _).trans |
| have hf:=h.progress _ (le_trans (show m+1 ≤ s.reach k i from e) (s.reach_le ..)) |
| have ht:=s.pegged (k:=k) hr e (Or.inl rfl) |
| have hx:=s.pegged (k:=k) hr e (Or.inr (Eq.refl (m+1))) |
| have ha : d.ton (f.shake m) ≤ 2*c*(s.wide*box (8*r)*lull s.key.a k) := by |
| apply hf.trans |
| rw [mul_assoc c,mul_add (box _)] |
| linarith [mul_le_mul_of_nonneg_left (add_le_add ht hx) h0] |
| let K:= 2*c*s.wide*lull s.key.a k |
| have hz:=mul_le_mul_of_nonneg_left ha (dry0 (18*r)).le |
| have hj : 0 ≤ K := mul_nonneg (mul_nonneg (by positivity) s.wide_nn) hu |
| have h' : box (8*r)*dry (18*r) ≤ decay s.L i*dry r:= breeze_charge r (s.gap i) h1 |
| have hy:=mul_le_mul_of_nonneg_left h' hj |
| apply hz.trans |
| unfold K at hy; unfold C; change _ ≤ _ * dry r |
| linarith |
| change ∑ x∈range (s.reach k i),_ ≤ _ |
| apply le_trans (sum_le_sum (fun j (hj:j∈range (s.reach k i))=> he j (mem_range.1 hj))) |
| rw [←mul_sum] |
| have hx := s.slack_plan i k |
| apply le_trans (mul_le_mul_of_nonneg_left hx heC) |
| exact le_of_eq (by dsimp [C]; ring) |
|
|
| end Line |
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| section |
|
|
| set_option synthInstance.maxSize 4096 |
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis Hie At Buf Finset |
|
|
| variable {n : ℕ} [Fact n.Prime] |
|
|
| lemma opposing (d:Axis) (f g : Pics n) : |
| d.ton (fun s i j=> f s i j-g s i j)=d.ton (fun s i j=> g s i j-f s i j) := by |
| rw [← d.ton_subnorm, ← d.ton_subnorm (f:=fun s i j=> g s i j-f s i j)] |
| congr! 2 |
| ext; rw [abs_sub_comm] |
| lemma joint (d : Axis) (f g a : Pics n) : |
| d.ton (fun s i j=> f s i j-g s i j) ≤ d.ton (fun s i j=>a s i j-f s i j)+ |
| d.ton (fun s i j=>a s i j-g s i j) := by |
| rw [opposing d a f] |
| have he := d.tplus (fun s i j=> f s i j-a s i j) (fun s i j=> a s i j-g s i j) |
| simp only [sub_add_sub_cancel] at he; exact he |
|
|
| namespace Line |
|
|
| lemma Due.negR {f:Line n} {s k d D b c} (h : Due s k d D b c f) : |
| Due s k d D b c ⟨fun m u i j=> -f.seq m u i j,fun i j=> -f.account i j⟩ := by |
| have hs:= h.eve |
| refine ⟨h.pos,by ext; simp [hs],fun m hi=>?_,fun m hi=>?_⟩ |
| · dsimp only |
| have he (i j) : d.fm (fun u i j=> -f.seq m u i j) i j= -d.fm (f.seq m) i j := by |
| simpa only [neg_mul,one_mul] using (d.fscalar (-1) (f.seq m) i j) |
| simp_rw [he,show ∀ x y:ℝ, -x - -y = -(x-y) from by intros; ring,toll_minus] |
| exact h.accuracy m hi |
| · unfold shake; simp_rw [show ∀ x y:ℝ,-x - -y = y-x from by intros; ring] |
| rw [opposing]; exact h.progress m hi |
|
|
| /-- Build unscaled strand, including a column rank or vector mean, from |
| ordinary discrepancy of its full estimates to true pre-mean inputs. -/ |
| lemma plain {s : Stair} {f:Line n} {d : Axis} {D b c} |
| (h:0≤c) {g:Pics n} (hd:∀ i∈d.S,∀ j∈d.S,0≤D i j) |
| (hs:f.seq 0 = fun _ _ _=>0) (ht:∀ i∈d.S,∀ j∈d.S,d.fm g i j=f.account i j) |
| (he:∀ m ≤ s.M-s.cut s.key.a,d.ton (fun u i j=>g u i j-f.seq m u i j) ≤ |
| c*s.theta m s.key.a) : Due s s.key.a d D b c f := by |
| let k:=s.key.a |
| refine ⟨h,hs,fun m hm=>?_,fun m hm=>?_⟩ |
| · let w:Pics n:=fun u i j=>f.seq m u i j-g u i j |
| have hh := he _ hm |
| have hg (u:Pool n) (i j) (hi:i∈src d.S d.u u) (hj:j∈dst d.S d.a u) : |
| |toll b (d.fm (f.seq m) i j-f.account i j) (D i j)| ≤ |d.fm w i j| := by |
| have hx := hd i (mem_filter.1 hi).1 j (mem_filter.1 hj).1 |
| rw [← ht i (mem_filter.1 hi).1 j (mem_filter.1 hj).1, show d.fm w i j=_ from d.fmean_sub ..,abs_of_nonneg (toll_nn hx)] |
| exact toll_tip hx |
| have hw := d.torder hg |
| refine hw.trans ?_ |
| rw [d.ton_subnorm (f:=fun s i j=> d.fm w i j)] |
| apply (d.fnorm w).trans |
| unfold w |
| rw [opposing] |
| simpa [salary,box] using hh |
| · have ht1:= joint d (f.seq (m+1)) (f.seq m) g |
| apply ht1.trans |
| have h1:= he (m+1) hm; have h2:=he m (by omega) |
| simp only [distn,Nat.sub_self,Nat.zero_add,Nat.mul_zero,box,pow_zero,mul_one] |
| linarith |
|
|
| lemma principal {s : Stair} {k : ℕ} {d : Axis} {D : Mat} {c K : ℝ} {f:Line n} |
| (h0 : d.a=s.key.a) |
| {a : ℕ→ Pics n} {g : Pics n} |
| (hs:f.seq=fun m=> d.carry k (a m)) (ha:a 0=fun _ _ _=>0) |
| (he : ∀ i∈d.S,∀ j∈d.S,d.fm (d.carry k g) i j=f.account i j) |
| (hh : ∀ i∈d.S,∀ j∈d.S,f.account i j≤K*D i j) |
| (hd : ∀ i∈d.S,∀ j∈d.S,0≤D i j) (hu:1≤K) (hc:0≤c) |
| (hn:2^nar d.a k≤n) |
| (hp : RCap K g) (hr:d.pinned (nar d.a k) g) |
| (h:∀ m ≤ s.M-s.cut k,RCap K (a m) ∧ d.pinned (nar d.a k) (a m) ∧ |
| (d.narrowed (nar d.a k)).terr g (a m) ≤ c*s.theta m k) : |
| Due s k d D true (Axis.paycheck K*c) f := by |
| have hhk:0≤K:=by linarith |
| have hv : 0≤Axis.paycheck K:=by unfold Axis.paycheck; positivity |
| refine ⟨by positivity,?_,fun m hm=>?_,fun m hm=>?_⟩ |
| · rw [hs]; ext; simp only [ha,Axis.carry,mul_zero] |
| · replace hh (i) (hi:i∈d.S) (j) (hj:j∈d.S) : |
| d.fm (d.carry k g) i j≤K*D i j := by rw [he _ hi _ hj]; exact hh _ hi _ hj |
| obtain ⟨h1,h2,h3⟩:=h m hm |
| have ht := d.stream_fee hn hu hp h1 hr h2 hd hh |
| have hy (i j) (hi:i∈d.S) (hj:j∈d.S) : toll true (d.fm (f.seq m) i j-f.account i j) (D i j)= |
| rel (d.fm (d.carry k g) i j-d.fm (d.carry k (a m)) i j) (D i j) := by |
| rw [hs,← he i hi j hj]; unfold toll rel; rw [abs_sub_comm]; rfl |
| rw [d.ton_ext (f:=fun (_:Pool n) i j=> _) (g:=fun u i j=> |
| rel (d.fm (d.carry k g) i j-d.fm (d.carry k (a m)) i j) (D i j)) |
| (fun _ _ _ hi hj=>hy _ _ (mem_filter.1 hi).1 (mem_filter.1 hj).1)] |
| have hx :=mul_le_mul_of_nonneg_left h3 |
| (show 0 ≤ Axis.paycheck K * salary d.a k from mul_nonneg hv (paypos _ _).le) |
| apply (ht.trans hx).trans; rw [h0]; exact le_of_eq (by ring) |
| · have hu (j : ℕ) (hj:j≤ s.M-s.cut k) : |
| d.ton (fun u i t=>d.carry k g u i t-f.seq j u i t)≤ |
| Axis.paycheck K*c*box (4*distn s.key.a k)*s.theta j k := by |
| obtain ⟨h1,h2,h3⟩:=h j hj |
| rw [hs] |
| have ht:= d.raw_fee hn hu hp h1 hr h2 |
| apply ht.trans |
| apply le_trans (mul_le_mul_of_nonneg_left h3 |
| (show 0≤Axis.paycheck K*box (4*distn d.a k) from mul_nonneg hv (box0 _).le)) |
| rw [h0]; exact le_of_eq (by ring) |
| unfold shake |
| apply (joint d _ _ (d.carry k g)).trans |
| linarith [hu (m+1) hm,hu m (by omega)] |
|
|
| end Line |
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| section |
|
|
| set_option synthInstance.maxSize 4096 |
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis Hie At Buf Finset |
|
|
| abbrev Ray := ℕ × ℕ |
|
|
| structure Flame (n : ℕ) where |
| rays : Finset Ray |
| lines : Ray→Line n |
| lamp : Mat |
| base : Mat |
|
|
| namespace Flame |
| variable {n : ℕ} [Fact n.Prime] |
| variable (f : Flame n) |
|
|
| def first (i : ℕ) := if i=0 then (fun _ _=>(0:ℝ)) else f.base |
| def portion (s : Stair) (d : Axis) (i : ℕ) : Pics n := |
| fun u x y=> ∑ t∈f.rays,(f.lines t).waveR s d t.1 i u x y+ |
| (if i=0 then f.base x y else 0) |
| def bundle (s : Stair) (d : Axis) (i : ℕ) : Pics n := |
| fun u x y=> if x∈src d.S d.u u ∧ y∈dst d.S d.a u then f.portion s d i u x y else 0 |
|
|
| def prefixR (s : Stair) (d : Axis) (i:ℕ) : Pics n := |
| fun u x y=> ∑ t∈f.rays,∑ m∈range (s.yoke t.1 i),(f.lines t).pick s d m u x y |
| + f.first i x y |
| def central (s : Stair) (d:Axis) (i:ℕ) : Mat := |
| fun x y=> ∑ t∈f.rays,d.fm ((f.lines t).seq (s.yoke t.1 i)) x y + f.first i x y |
| def smoke (s : Stair) (d:Axis) (i:ℕ) : Pics n := |
| fun u x y=> ∑ t∈f.rays,(f.lines t).weatherR s d t.1 i u x y |
|
|
| lemma prefix0 (s d u x y) : f.prefixR s d 0 u x y=0 := by simp [prefixR,first, Stair.yoke] |
| lemma next (s d i u x y) : |
| f.prefixR s d i u x y+f.portion s d i u x y=f.prefixR s d (i+1) u x y := by |
| unfold prefixR portion |
| let p (j : ℕ) (t:Ray) := ∑ m ∈ range (s.yoke t.1 j),(f.lines (t:Ray)).pick s d m u x y |
| have H (t:Ray) : p i t+(f.lines t).waveR s d t.1 i u x y = p (i+1) t := |
| s.union_sum i _ _ |
| have he : f.first i x y + (if i=0 then f.base x y else 0)=f.first (i+1) x y := by |
| unfold first; by_cases hi:i=0 <;> simp [hi] |
| have ht := sum_congr rfl (s₁:=f.rays) fun t _=> H t |
| rw [sum_add_distrib] at ht |
| change ∑ t∈f.rays,p i t+f.first i x y+(∑ t∈f.rays,_ +_) = |
| ∑ t∈f.rays,p (i+1) t+ _ |
| linarith |
|
|
| def tail (x y : ℕ) := |
| f.lamp x y-f.base x y-∑ t∈f.rays,(f.lines t).account x y |
|
|
| structure Owes (s : Stair) (d : Axis) (b : Bool) (c : ℝ) (f : Flame n) : Prop where |
| on : 0< s.key.r |
| breeze : Wind 18 s.lam |
| coef : 1≤c |
| due : ∀ t∈ f.rays,Line.Due s t.1 d f.lamp b c (f.lines t) |
| gone : d.ton (n:=n) (w:=0) (fun _=> f.tail) ≤ c*s.wide |
| heat : ∑ t∈f.rays,lull s.key.a t.1 ≤ c |
| positive : ∀ x∈d.S,∀ y∈d.S,0≤ f.lamp x y |
|
|
| lemma Owes.more {s : Stair} {d b c c'} {f : Flame n} (h:Owes s d b c f) (he:c≤c') : |
| Owes s d b c' f := |
| ⟨h.on,h.breeze,h.coef.trans he,fun i hi=>(h.due i hi).enlarge he, |
| h.gone.trans (mul_le_mul_of_nonneg_right he s.wide_nn), |
| h.heat.trans he,h.positive⟩ |
|
|
| lemma coupling {s d b c} (h:Owes s d b c f) (i u x y) : |
| f.prefixR s d i u x y=f.central s d i x y+f.smoke s d i u x y := by |
| unfold prefixR central smoke |
| have hx := sum_congr (s₁:=f.rays) rfl fun j hj=> |
| (f.lines j).runoff s d j.1 i (h.due j hj).eve u x y |
| rw [sum_add_distrib] at hx; rw [hx]; ring |
|
|
| abbrev contract (s:Stair) (c:ℝ) := (4*c^2)*s.wide |
| lemma protocol {s : Stair} {c : ℝ} : 0≤contract s c := |
| mul_nonneg (by positivity) (s.wide_nn) |
|
|
| lemma fumes {s d b c} (h:Owes s d b c f) (i : ℕ) : |
| d.ton (f.smoke s d (i+1)) ≤ contract s c*decay s.L i := by |
| apply le_trans (d.tseries (fun j=> (f.lines j).weatherR s d j.1 (i+1)) _) |
| apply le_trans (sum_le_sum (fun j hj=>(f.lines j).foggy (h.due j hj) h.breeze h.on i)) |
| rw [← mul_sum] |
| have hp:= s.wide_nn; have hc:0≤c:= le_trans zero_le_one h.coef |
| have hs : 0≤ decay s.L i:=(dry0 _).le |
| apply le_trans (mul_le_mul_of_nonneg_left h.heat (by positivity)) |
| exact le_of_eq (by unfold contract; ring) |
|
|
| def picture (s : Stair) (d : Axis) (b : Bool) (i : ℕ) : Mat := |
| fun x y=>toll b (f.central s d (i+1) x y-f.lamp x y) (f.lamp x y) |
|
|
| lemma pink {s d b c} (h:Owes s d b c f) (i : ℕ) : |
| d.ton (n:=n) (w:=0) (fun _=>f.picture s d b i) ≤ contract s c*liftB 2 s.L i := by |
| let p (j:Ray) : Mat:= fun x y=> d.fm ((f.lines j).seq (s.reach j.1 i)) x y- |
| (f.lines j).account x y |
| let m (j:Ray) : Pics n:= fun _ x y=> toll b (p j x y) (f.lamp x y) |
| let v : Pics n := fun u x y=> ∑ j∈f.rays,m j u x y |
| let z : Pics n:= fun _ x y=> |f.tail x y| |
| have he (u:Pool n) (x y:ℕ) (hx:x∈ src d.S d.u u) (hy:y∈dst d.S d.a u) : |
| |f.picture s d b i x y|≤ v u x y+z u x y := by |
| have hl := h.positive x (mem_filter.1 hx).1 y (mem_filter.1 hy).1 |
| have hz : f.central s d (i+1) x y - f.lamp x y = |
| ∑ j∈f.rays,p j x y+ -(f.tail x y) := by |
| simp only [central,first,p,tail,sum_sub_distrib,show i+1≠0 by omega, ↓reduceIte, |
| Stair.yoke] |
| ring |
| unfold picture; rw [abs_of_nonneg (toll_nn hl),hz] |
| apply (toll_add hl).trans |
| refine add_le_add (toll_sum _ _ hl _) (by rw [toll_minus]; exact toll_tip hl) |
| have hs := d.torder he |
| apply hs.trans |
| apply (d.tplus v z).trans |
| have h1 : d.ton z ≤ c*s.wide := by |
| unfold z; rw [d.ton_subnorm]; exact h.gone |
| let u:=liftB 2 s.L i |
| have h0 := h.coef; have hp:=s.wide_nn |
| have hu:1 ≤ u:=lift_one .. |
| have h2 : d.ton v ≤ c^2*s.wide*u := by |
| apply le_trans (d.tseries m _) |
| apply le_trans (sum_le_sum (fun j hj=> show d.ton (m j) ≤ c*s.wide*u*lull s.key.a j.1 from |
| (f.lines j).winning (h.due j hj) h.on i)) |
| rw [← mul_sum] |
| apply le_trans (mul_le_mul_of_nonneg_left h.heat (by positivity)) |
| exact le_of_eq (by ring) |
| unfold contract; change _ ≤ _ * u |
| have hh : c*s.wide ≤ c^2*s.wide*u := |
| le_trans (mul_le_mul_of_nonneg_right (by nlinarith : c ≤ c^2) hp) |
| (by nlinarith [show 0≤c^2*s.wide from by positivity]) |
| have hk : 0 ≤ c^2*s.wide*u := by positivity |
| linarith |
|
|
| lemma tip_noise {s d b c} (h:Owes s d b c f) (i u) {x y} |
| (hx:x∈d.S) (hy:y∈d.S) : |
| toll b (f.prefixR s d (i+1) u x y-f.lamp x y) (f.lamp x y) ≤ |
| f.picture s d b i x y + |f.smoke s d (i+1) u x y| := by |
| rw [f.coupling h,show f.central s d (i+1) x y+ f.smoke s d (i+1) u x y-f.lamp x y= |
| f.central s d (i+1) x y-f.lamp x y+ f.smoke s d (i+1) u x y by ring] |
| have he := h.positive _ hx _ hy |
| exact (toll_add he).trans (add_le_add_right (toll_tip he) _) |
|
|
| end Flame |
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| section |
|
|
| set_option synthInstance.maxSize 2048 |
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis Hie Buf At Finset |
|
|
| variable {n w : ℕ} [Fact n.Prime] |
| /-- Inputs to the compression estimate. -/ |
| structure Spray (n w : ℕ) [Fact n.Prime] where |
| d : Axis |
| t : ℕ |
| L : ℕ |
| K : ℕ |
| b : ℕ |
| a : Mat |
| q : Mat |
| inc : ℕ → X n w→ℕ → Buf.Row |
| lead : ℕ → Mat |
| seedB : ℕ → Mat |
| fog : ℕ → TableF n w |
|
|
| namespace Spray |
| variable (s : Spray n w) |
| abbrev dst0 (i : X n w) := dst s.d.S s.d.a i |
| abbrev dst1 (i : X n w) := dst s.d.S s.t i |
| abbrev src0 (i : X n w) := src s.d.S s.d.u i |
| def go (u : X n w) (i : ℕ) : Run := |
| ⟨s.L,s.dst0 u,s.K,capacity s.b s.K s.L,floorR s.b s.L,fun j=>s.inc j u i, |
| fun x=>(s.a i x, if x∈s.dst1 u then s.q i x else 0)⟩ |
| def s1 (j : ℕ) : TableF n w := fun _=> s.lead j |
| def s2 (j:ℕ) : TableF n w := s.d.wmask s.t (fun _=>s.seedB j) |
| def pay (j:ℕ) : TableF n w := fun u i x=> s.s1 j u i x+s.s2 j u i x+s.fog j u i x |
|
|
| structure Works (p M : ℝ) : Prop where |
| pos : 0≤ p |
| mass : 1≤ M |
| len : 0<s.L |
| legal : Hie.legal n s.d.S |
| kind : s.d.a≤ s.t |
| window : 2^s.d.a ≤ n |
| side : ∀ i∈s.d.S, ∀ j∈s.d.S,0≤ s.a i j ∧ |s.q i j|≤zeta ∧ |
| (s.a i j ≤ At.small → s.q i j=0) |
| row : ∀ i∈s.d.S,(∑ j ∈ s.d.S,s.a i j)*rate s.d.a ≤M |
| error : ∀ j<s.L,∀ u,∀ i∈s.src0 u,∀ x∈s.dst0 u,(s.go u i).epi j x≤ s.pay j u i x |
| h1 : ∀ j<s.L,s.d.ton (s.s1 j) ≤ p*liftB s.b s.L j |
| h2 : ∀ j<s.L,s.d.ton (s.s2 j) ≤ p*liftB s.b s.L j |
| noise : ∀ j<s.L,s.d.ton (s.fog j) ≤ p*decay s.L j |
|
|
| lemma ok {p M} (h:s.Works p M) {u i} (he:i∈s.src0 u) : (s.go u i).Good := by |
| have H (j) (hj : j∈s.dst0 u) := h.side i (mem_filter.1 he).1 j (mem_filter.1 hj).1 |
| exact ⟨fun j _=>floor_pos ..,totaldust ..,fun i hi=>lead_dust _ _ _ hi,fun i _=>cap_K .., |
| fun j hj=>(H j hj).1,fun j hj=>by |
| have := (H j hj).2.1 |
| by_cases h:j∈s.dst1 u <;> simp only [go,h,ite_true,ite_false] |
| · exact this |
| simp [zeta]; have :=smallp; positivity, |
| fun j hj hx=> by |
| have h := (H _ hj).2.2 hx |
| simp [go,h]⟩ |
|
|
| lemma pay_pub {p M} (h:s.Works p M) {i} (hi:i<s.L) : |
| s.d.ton (s.pay i) ≤ 3*p*liftB s.b s.L i := by |
| apply le_trans (s.d.tplus _ (s.fog i)) |
| have he := s.d.tplus (s.s1 i) (s.s2 i) |
| have hv:=mul_le_mul_of_nonneg_left (decay_le s.b s.L i) h.pos |
| linarith [h.noise i hi,h.h1 i hi,h.h2 i hi] |
|
|
| def heavy (i x : ℕ) := |
| s.d.S.filter fun j=> floorR s.b s.L i/4 < s.a x j |
| lemma binge_bits (j : ℕ) u i : |
| (s.go u i).fatties j = retain s.d.a (s.heavy j i) u.2.1 := by |
| ext x; simp only [go,Run.fatties,dst0,dst,retain,heavy,mem_filter]; tauto |
| def busy (j i : ℕ) (u : Channel n) : Prop := |
| capacity s.b s.K s.L j ≤ 2*(retain s.d.a (s.heavy j i) u).card |
| instance (j i : ℕ) (u : Channel n) : Decidable (s.busy j i u) := by unfold busy; infer_instance |
| lemma wrapped (j) u i : (s.go u i).binge j ↔ s.busy j i u.2.1 := by |
| rw [Run.binge, binge_bits]; rfl |
|
|
| lemma cut_belly {p M} (h:s.Works p M) (j) {x} (hx:x∈s.d.S) : |
| ((s.heavy j x).card:ℝ)*floorR s.b s.L j*rate s.d.a ≤ 4*M := by |
| let u:=floorR s.b s.L j |
| have he : (s.heavy j x).card * (u/4) ≤ ∑ k∈s.d.S,s.a x k := calc |
| _ = ∑ i∈s.heavy j x, u/4 := by simp |
| _ ≤ ∑ i∈s.heavy j x, s.a x i := sum_le_sum fun i hi=> le_of_lt (mem_filter.1 hi).2 |
| _ ≤ _ := sum_le_sum_of_subset_of_nonneg (filter_subset ..) |
| fun i hi _=>(h.side _ hx _ hi).1 |
| have ht:= h.row x hx |
| have hk := le_trans (mul_le_mul_of_nonneg_right he (rate_pos _).le) ht |
| change _*u*_ ≤ _ |
| linarith |
|
|
| abbrev hefty (M : ℝ) := 1024*M |
| lemma raid {p M} (h:s.Works p M) (t i) {x y : ℕ} (hx:x∈s.d.S) (hy:y∈s.d.S) : |
| atP t (↑y:ZMod n) (fun c:Channel n=> if s.busy i x c then (1:ℝ) else 0) |
| ≤ (hefty M * firm s.b s.K s.L i)^4 := by |
| let N : ℝ := capacity s.b s.K s.L i |
| let z := floorR s.b s.L i |
| let l:= s.heavy i x |
| let R :=rate s.d.a |
| let m := atP t (↑y:ZMod n) (fun c:Channel n=>if s.busy i x c then (1:ℝ) else 0) |
| have hh : N*m ≤ 2*atP t (↑y:ZMod n) (tally s.d.a l) := by |
| unfold m atP; rw [← av_cmul,← av_cmul] |
| apply av_mono |
| intro c; dsimp only; split |
| · next e=> |
| rw [mul_one] |
| unfold busy at e; unfold N tally l |
| exact_mod_cast e |
| · rw [mul_zero]; unfold tally; positivity |
| have hcap:=feed_power s.b s.K s.L i |
| have hT : atP t (↑y:ZMod n) (tally s.d.a l)≤ 1+(l.card:ℝ)*(32*R):= |
| tally_cond (S:=l) (fun i hi=>h.legal ((filter_subset _ _) hi)) h.window _ (mem_range.1 (h.legal hy)) |
| have hl:=s.cut_belly h i hx |
| have hM:=h.mass |
| have hz : 0<z:= floor_pos .. |
| have hz' : z≤1:=dry_one _ |
| have hN : 0<N := by unfold N; exact_mod_cast cap_pos s.b s.K s.L i |
| change (l.card:ℝ)*z*R≤4*M at hl |
| change 1≤ N*z*(firm s.b s.K s.L i)^4 at hcap |
| change m≤_ |
| apply le_of_mul_le_mul_left _ (show 0<N*z by positivity) |
| have he2 : N*z*m ≤260*M := by |
| have ht : N*m ≤2*(1+l.card*32*R) := by linarith |
| nlinarith [mul_le_mul_of_nonneg_left ht hz.le] |
| apply le_trans he2 _ |
| have hE0 : hefty M ≥ 1024 := by unfold hefty; linarith |
| have hE : 260*M ≤ (hefty M)^4 := by unfold hefty at *; nlinarith [sq_nonneg (M^2-1)] |
| have hk:=mul_le_mul_of_nonneg_left hcap (show 0≤ (hefty M)^4 by positivity) |
| rw [mul_pow]; linarith |
|
|
| end Spray |
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| section |
|
|
| set_option synthInstance.maxSize 2048 |
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis Hie At Buf Finset |
| open scoped Classical |
|
|
| namespace Spray |
| variable {n w : ℕ} [Fact n.Prime] |
| variable (s : Spray n w) |
| def mh (j : ℕ) : Vertex n w := fun u i=> s.d.head (s.s1 j) u i+s.d.head (s.s2 j) u i |
| def nh (j : ℕ) := s.d.head (s.fog j) |
| def both (j : ℕ) : Vertex n w := fun u i=> s.mh j u i+s.nh j u i |
|
|
| lemma mnn (j) u i : 0≤ s.mh j u i:=add_nonneg (Axis.head_nn ..) (Axis.head_nn ..) |
| lemma nnn (j) u i : 0≤ s.nh j u i:=Axis.head_nn .. |
| lemma bnn (j) u i : 0≤ s.both j u i:=add_nonneg (s.mnn j u i) (s.nnn j u i) |
| lemma pointed {j p M} (h:s.Works p M) (hz:j<s.L) {u i} (hi:i∈s.src0 u) : |
| (s.go u i).bad j ≤ s.both j u i := by |
| apply rank_le (s.bnn ..) |
| intro k hk |
| apply le_trans (h.error j hz u i hi k hk) |
| have hu (f : TableF n w) : f u i k ≤ s.d.head f u i := |
| le_trans (le_abs_self _) (s.d.head_ge f u i hk) |
| exact add_le_add (add_le_add (hu ..) (hu ..)) (hu ..) |
|
|
| lemma nh_ub {p M} (h:s.Works p M) {j} (hi : j<s.L) : |
| s.d.von (s.nh j) ≤ p*decay s.L j := by rw [nh,s.d.head_e]; exact h.noise _ hi |
| lemma mh_ub {p M} (h:s.Works p M) {j} (hi:j<s.L) : |
| s.d.von (s.mh j) ≤ 2*p*liftB s.b s.L j := by |
| apply le_trans (s.d.vplus (s.d.head (s.s1 j)) (s.d.head (s.s2 j))) |
| rw [s.d.head_e,s.d.head_e]; linarith [h.h1 j hi,h.h2 j hi] |
| lemma both_ub {p M} (h:s.Works p M) {j} (hi:j<s.L) : |
| s.d.von (s.both j) ≤3*p*liftB s.b s.L j := by |
| apply le_trans (s.d.vplus (s.mh j) (s.nh j)) |
| have he := s.mh_ub h hi; have hn := s.nh_ub h hi |
| linarith [mul_le_mul_of_nonneg_left (decay_le s.b s.L j) h.pos] |
|
|
| def phantom (j : ℕ) : Vertex n w := |
| fun u i=> if (s.go u i).hap j ∧ ¬(s.go u i).binge j then 1 else 0 |
| lemma false_nn (j) u i : 0≤ s.phantom j u i := by unfold phantom; split <;> norm_num |
| abbrev fc (s : Spray n w) (i : ℕ) := firm s.b s.K s.L i |
| set_option maxHeartbeats 500000 in |
| lemma false_ub {p M} (h:s.Works p M) {j} (hi:j<s.L) : |
| s.d.von (s.phantom j) ≤ 64*s.fc j*p*liftB s.b s.L j := by |
| let N:ℝ:=capacity s.b s.K s.L j |
| let R:=floorR s.b s.L j |
| let A:= N/2*(R/8)^4 |
| let b:=liftB s.b s.L j |
| let e:=s.fc j |
| let f:=s.pay j |
| have he (u) (i) (hx:i∈s.src0 u) : |
| A*(s.phantom j u i)^4 ≤ ∑ k∈s.dst0 u,(f u i k)^4 := by |
| unfold phantom; split |
| · next hn=> |
| simp only [one_pow,mul_one] |
| apply le_trans (Run.fake (s.go u i) (s.ok h hx) hi hn.1 hn.2) |
| apply sum_le_sum; intro k hk |
| exact pow_le_pow_left₀ (Run.epi_nn ..) (h.error j hi u i hx k hk) 4 |
| · simp only [zero_pow ((show (4:ℕ) ≠ 0 by omega)),mul_zero] |
| exact sum_nonneg fun _ _ => by positivity |
| have ht : A * s.d.von (s.phantom j)^4≤ (3*p*b)^4 := calc |
| _ = s.d.vi (fun u i=>A*s.phantom j u i^4) := by rw [s.d.von_four,s.d.vmul] |
| _ ≤ _ := s.d.vi_mono he |
| _ = s.d.ton (s.pay j)^4 := (s.d.ton_four _).symm |
| _ ≤ _ := pow_le_pow_left₀ (s.d.tn0 _) (s.pay_pub h hi) _ |
| have hp:=h.pos; have hN : 0<N := by unfold N; exact_mod_cast cap_pos s.b s.K s.L j |
| have hR : 0 < R:= floor_pos .. |
| have hz : 0<e:= dry0 _ |
| have hb : 0<b:= box0 _ |
| have hu : 1 ≤ N*R^4*e^4 := forfeit s.b s.K s.L j |
| change _ ≤ 64*e*p*b |
| apply (s.d.vm_le (by positivity)).mpr |
| rw [← s.d.von_four] |
| apply le_of_mul_le_mul_left _ (show 0<A by unfold A; positivity) |
| apply ht.trans |
| let d:=p*b |
| have hg : d^4 ≤ N*R^4*e^4*d^4 := by |
| simpa using mul_le_mul_of_nonneg_right hu (show 0 ≤ d^4 by positivity) |
| rw [show 3*p*b=3*d by dsimp [d]; ring, show 64*e*p*b=64*e*d by dsimp [d]; ring] |
| unfold A |
| nlinarith [show 0≤d^4 by positivity] |
|
|
| def chip (j : ℕ) (f : TableF n w) : TableF n w := |
| fun u i k=> if s.busy j i u.2.1 then f u i k else 0 |
| def chipV (j : ℕ) (f : Vertex n w) : Vertex n w := |
| fun u i=> if s.busy j i u.2.1 then f u i else 0 |
|
|
| lemma chipH (j : ℕ) (f : TableF n w) : |
| s.chipV j (s.d.head f)=s.d.head (s.chip j f) := by |
| ext u i; exact (s.d.head_mask (fun u i=>s.busy j i u.2.1) f u i).symm |
|
|
| lemma busy_avg {p M} (h:s.Works p M) (j l) {x y : ℕ} |
| (hx:x∈s.d.S) (hy:y∈s.d.S) (u : ℝ) : |
| @Env.cond n w _ s.d.u l (↑x:ZMod n) (↑y:ZMod n) |
| (fun c=> (if s.busy j x c.2.1 then u else 0)^4) |
| ≤ (hefty M*s.fc j)^4* |
| @Env.cond n w _ s.d.u l (↑x:ZMod n) (↑y:ZMod n) (fun _ => u^4) := by |
| let F (c : Channel n) := (if s.busy j x c then u else 0)^4 |
| have he1 : @Env.cond n w _ s.d.u l (↑x:ZMod n) (↑y:ZMod n) (fun c=> F c.2.1)= |
| atP l (↑y:ZMod n) F := by |
| unfold Env.cond atP |
| simp only [av_prod,Env.outward,av_const] |
| have hA (c:Channel n) : F c=u^4*(if s.busy j x c then (1:ℝ) else 0) := by |
| unfold F; split <;> norm_num |
| change @Env.cond n w _ _ _ _ _ (fun c=> F c.2.1) ≤ _ |
| rw [he1] |
| simp only [Env.cond,atP,hA,av_const,av_cmul] |
| have hv:=s.raid h l j hx hy |
| conv_rhs => rw [mul_comm] |
| exact mul_le_mul_of_nonneg_left hv (show 0≤u^4 by positivity) |
|
|
| set_option maxHeartbeats 500000 in |
| lemma slice_costa {p M} (h:s.Works p M) (j l) (f : Mat) : |
| (s.d.narrowed l).ton (s.chip j (fun _=> f)) ≤ |
| hefty M*s.fc j*(s.d.narrowed l).ton (fun (_:X n w)=> f) := by |
| let d:=s.d.narrowed l |
| let c:=hefty M*s.fc j |
| have hc:0<c := mul_pos (show 0<hefty M by unfold hefty; linarith [h.mass]) (dry0 _) |
| change d.ton _ ≤ c*d.ton _ |
| apply (d.tm_le (mul_nonneg hc.le (d.tn0 _))).mpr |
| rw [mul_pow,d.ton_four, d.conditional,d.conditional] |
| rw [mul_left_comm (c^4)] |
| apply mul_le_mul_of_nonneg_left _ (scaleM_nn ..) |
| rw [mul_sum] |
| apply sum_le_sum; intro x hx |
| rw [mul_sum] |
| apply sum_le_sum; intro y hy |
| rw [mul_left_comm (c^4)] |
| refine mul_le_mul_of_nonneg_left (busy_avg s h j _ hx hy _) ?_ |
| exact mul_nonneg (pct_pos (NeZero.pos n) _).le (pct_pos (NeZero.pos n) _).le |
|
|
| lemma masked_leaf {p M} (h:s.Works p M) (i j) : |
| s.d.von (s.chipV i (s.mh j)) ≤ |
| hefty M*s.fc i*(s.d.ton (s.s1 j)+s.d.ton (s.s2 j)) := by |
| let w1:=s.d.head (s.s1 j) |
| let w2:=s.d.head (s.s2 j) |
| have he : s.chipV i (s.mh j)=fun u x=>s.chipV i w1 u x+s.chipV i w2 u x := by |
| ext u x; unfold chipV; split |
| · rfl |
| · norm_num |
| rw [he,mul_add] |
| apply (s.d.vplus (s.chipV i w1) (s.chipV i w2)).trans (add_le_add ?_ ?_) |
| · unfold w1 |
| rw [chipH,s.d.head_e] |
| exact s.slice_costa h i s.d.a (s.lead j) |
| unfold w2; rw [chipH,s.d.head_e]; unfold s2 |
| have hv (f : TableF n w) : s.chip i (s.d.wmask s.t f)=s.d.wmask s.t (s.chip i f) := by |
| ext u x y; unfold chip Axis.wmask; grind |
| rw [hv,s.d.tmask s.t h.kind,s.d.tmask s.t h.kind] |
| exact s.slice_costa h i s.t (s.seedB j) |
| lemma masked_ub {p M} (h:s.Works p M) (i j) (he:j<s.L) : |
| s.d.von (s.chipV i (s.mh j)) ≤ |
| hefty M*s.fc i*(2*p*liftB s.b s.L j) := by |
| have ht : 0≤ hefty M := by unfold hefty; linarith [h.mass] |
| apply (s.masked_leaf h i j).trans (mul_le_mul_of_nonneg_left _ (mul_nonneg ht (dry0 _).le)) |
| linarith [h.h1 j he,h.h2 j he] |
|
|
| end Spray |
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| section |
|
|
| set_option synthInstance.maxSize 2048 |
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis Hie At Buf Finset |
| open scoped Classical |
|
|
| namespace Spray |
| variable {n w : ℕ} [Fact n.Prime] |
| variable (s : Spray n w) |
|
|
| def sky (j : ℕ) : Vertex n w := |
| fun u i => (24/small * floorR s.b s.L j)*s.both j u i |
| def clouds : Vertex n w := |
| fun u i=>∑ j∈range s.L,s.sky j u i |
| def trail (j : ℕ) : Vertex n w := |
| fun u i=>∑ k∈Ico j s.L,(32:ℝ)^(s.L-k)*s.chipV j (s.mh k) u i |
| def march : Vertex n w := |
| fun u i=>∑ j∈range s.L,s.trail j u i |
| def rim : Vertex n w := |
| fun u i=>32*s.mh (s.L-1) u i |
| def thunder : Vertex n w := |
| fun u i=>∑ j∈range s.L,(32:ℝ)^(s.L-j)*s.nh j u i |
| def beasts : Vertex n w := |
| fun u i=> ∑ j∈range s.L,s.phantom j u i |
| def sumB : Vertex n w := |
| fun u i=> s.clouds u i+s.march u i+s.rim u i+s.thunder u i+s.beasts u i |
|
|
| lemma sky_nn (j) u i : 0≤ s.sky j u i := mul_nonneg |
| (mul_nonneg (div_nonneg (by norm_num) smallp.le) (floor_pos ..).le) (s.bnn ..) |
| lemma clouds_nn u i : 0≤ s.clouds u i:=sum_nonneg fun _ _=> s.sky_nn .. |
| lemma trail_nn (j) u i : 0≤ s.trail j u i := |
| sum_nonneg fun k _=>mul_nonneg (by positivity) (by unfold chipV; split; apply s.mnn; norm_num) |
| lemma march_nn u i : 0≤ s.march u i:=sum_nonneg fun _ _=>s.trail_nn .. |
| lemma rim_nn u i : 0≤ s.rim u i:=mul_nonneg (by norm_num) (s.mnn ..) |
| lemma thunder_nn u i : 0≤ s.thunder u i:= |
| sum_nonneg fun k _=>mul_nonneg (by positivity) (s.nnn ..) |
| lemma beasts_nn u i : 0≤ s.beasts u i:=sum_nonneg fun _ _=>s.false_nn .. |
| lemma sumB_nn u i : 0 ≤ s.sumB u i := by |
| unfold sumB; linarith [s.clouds_nn u i,s.march_nn u i,s.rim_nn u i,s.thunder_nn u i, |
| s.beasts_nn u i] |
|
|
| lemma cloud_plan {p M} (h:s.Works p M) {u i} (hs:i∈s.src0 u) {j} (hj:j<s.L) : |
| (s.go u i).rain j ≤ s.clouds u i := by |
| unfold Run.rain clouds |
| refine le_trans ?_ (sum_le_sum_of_subset_of_nonneg (range_mono hj.le) (fun x hx _=>s.sky_nn x u i)) |
| apply sum_le_sum; intro k hk |
| exact mul_le_mul_of_nonneg_left (s.pointed h ((mem_range.1 hk).trans hj) hs) |
| (mul_nonneg (div_nonneg (by norm_num) smallp.le) (floor_pos ..).le) |
|
|
| lemma tail_route {p M} (h:s.Works p M) {u i} (hs:i∈s.src0 u) {j} (hi:j<s.L) |
| (hh : s.L=j+1 ∨ (s.go u i).binge j) : |
| (s.go u i).tail j ≤ s.march u i+s.rim u i+s.thunder u i := by |
| let a:= (∑ k∈Ico j s.L,(32:ℝ)^(s.L-k)*s.mh k u i) |
| let b:= (∑ k∈Ico j s.L,(32:ℝ)^(s.L-k)*s.nh k u i) |
| have hz : (s.go u i).tail j≤a+b := by |
| unfold Run.tail a b; rw [← sum_add_distrib]; apply sum_le_sum |
| intro k hk; rw [← mul_add] |
| exact mul_le_mul_of_nonneg_left (s.pointed h (mem_Ico.1 hk).2 hs) (by positivity) |
| have hb : b≤ s.thunder u i := by |
| apply sum_le_sum_of_subset_of_nonneg (fun k hi=>mem_range.2 (mem_Ico.1 hi).2) |
| (fun k hk _=>mul_nonneg (by positivity) (s.nnn ..)) |
| apply hz.trans (add_le_add _ hb) |
| obtain hl|hl:=hh |
| · have hs0 : s.L-1=j := by omega |
| have he : a=s.rim u i := by |
| dsimp only [a,rim] |
| rw [hl] |
| simp |
| rw [he]; linarith [s.march_nn u i] |
| have ha : a=s.trail j u i := by simp [a,trail,chipV,(s.wrapped j u i).1 hl] |
| have he : s.trail j u i ≤ s.march u i := by |
| unfold march; exact single_le_sum (f:=fun k=> s.trail k u i) (fun k _=>s.trail_nn k u i) (mem_range.mpr hi) |
| rw [ha]; linarith [s.rim_nn u i] |
|
|
| def diff (f : Trio) : TableF n w := |
| fun u i k=> let r:=s.go u i |
| fourth ((r.mid s.L).val r.S r.K f k)-fourth (r.origin.val r.S r.K f k) |
|
|
| lemma receipt {theta C f p M} (h:s.Works p M) (hf:TS theta C f) (hz:delta≤theta) |
| (hc:theta≤1) {u i k} (hi:i∈s.src0 u) (hk:k∈s.dst0 u) : |
| |s.diff f u i k| ≤ Run.charge C*s.sumB u i := by |
| let r:=s.go u i |
| obtain ⟨j,hj,hl,hp⟩:=r.earliest h.len |
| have hC := hf.start.one |
| have h1 : 0<C^3 := pow_pos (by linarith) _ |
| have he1 : 1 ≤ Run.wideK (C+12) := by unfold Run.wideK; linarith |
| have hu : C^3 ≤ Run.charge C := by unfold Run.charge; nlinarith |
| by_cases he : r.L=j+1 ∨ r.binge j |
| · have hT := s.tail_route h hi hj he |
| have hD := s.cloud_plan h hi hj |
| apply (r.wave (s.ok h hi) hf hz hc hj hl hk).trans (mul_le_mul_of_nonneg_left _ (by linarith)) |
| unfold sumB r; linarith [s.beasts_nn u i] |
| obtain hl1 : r.overflow j:=hp.resolve_left (fun e=> he (Or.inl e)) |
| have hb : s.phantom j u i=1 := ite_eq_left ⟨⟨hl,hl1⟩,fun e=>he (Or.inr e)⟩ |
| have hp : 1≤ s.beasts u i := by |
| unfold beasts |
| exact le_trans (le_of_eq hb.symm) (single_le_sum (f:=fun k=>s.phantom k u i) |
| (fun k _=>s.false_nn k u i) (mem_range.2 hj)) |
| have hs : 1 ≤ s.sumB u i := by unfold sumB; linarith [s.clouds_nn u i,s.march_nn u i,s.rim_nn u i,s.thunder_nn u i] |
| have hC0 (v : Blob) : 0≤fourth (v.val r.S r.K f k) ∧ fourth (v.val r.S r.K f k)≤C^3 := |
| ⟨fourth_nn _,hf.rootub ..⟩ |
| change |fourth ((r.mid s.L).val r.S r.K f k)-fourth (r.origin.val r.S r.K f k)| ≤ _ |
| obtain ⟨ha,hb⟩:=hC0 (r.mid s.L) |
| obtain ⟨he,hk2⟩:=hC0 r.origin |
| refine le_trans (b:=C^3) ?_ ?_ |
| · rw [abs_le]; constructor <;> linarith |
| nlinarith |
|
|
| end Spray |
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| section |
|
|
| set_option synthInstance.maxSize 2048 |
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis Hie At Buf Finset |
| open scoped Classical |
|
|
| namespace Spray |
| variable {n w : ℕ} [Fact n.Prime] |
| variable (s : Spray n w) |
|
|
| abbrev droplets := (24/At.small)*3 |
| lemma vgeo {c : ℝ} (he:0≤c) {f : ℕ→ Vertex n w} |
| (h : ∀ i<s.L,s.d.von (f i) ≤ c*dry (gapD s.L i)) : |
| s.d.von (fun u i=>∑ j∈range s.L,f j u i) ≤ c*2 := by |
| apply le_trans (s.d.vseries f (range s.L)) |
| have hd := sum_le_sum (s:=range s.L) fun i hi=> h i (mem_range.1 hi) |
| apply hd.trans |
| rw [← mul_sum]; exact mul_le_mul_of_nonneg_left (binsum s.L) he |
|
|
| lemma droplets_ub {p M} (h:s.Works p M) : |
| s.d.von s.clouds ≤ droplets*p*2 := by |
| let a:=24/small |
| have hp:=h.pos; have ha : 0≤a:=div_nonneg (by norm_num) smallp.le |
| apply s.vgeo (by change 0≤a*3*p; positivity) (f:=s.sky) |
| intro j hi |
| let r:=floorR s.b s.L j |
| have hr : 0≤ r:= (floor_pos ..).le |
| change s.d.von (fun u i=>a*r*s.both j u i) ≤ _ |
| rw [s.d.vscale,abs_of_nonneg (by positivity)] |
| have he:=floor_lift s.b s.L j |
| have ht:=mul_le_mul_of_nonneg_left (s.both_ub h hi) (show 0 ≤ a*r by positivity) |
| refine ht.trans ?_ |
| change a*r*_ ≤ a*3*p*_ |
| change r*_ ≤ _ at he |
| have hd:=mul_le_mul_of_nonneg_left he (show 0≤ a*3*p by positivity) |
| linarith |
|
|
| lemma beasts_ub {p M} (h:s.Works p M) : |
| s.d.von s.beasts ≤ 64*p*2 := by |
| have hp:=h.pos |
| apply s.vgeo (by positivity) (f:=s.phantom) |
| intro j hi |
| apply (s.false_ub h hi).trans |
| have hh:= mul_le_mul_of_nonneg_left (firm_plain s.b s.K s.L j) (show 0≤64*p by positivity) |
| unfold fc; linarith |
|
|
| lemma thunder_ub {p M} (h:s.Works p M) : |
| s.d.von s.thunder ≤ p*2 := by |
| apply s.vgeo h.pos (f:=fun j u i=>(32:ℝ)^(s.L-j)*s.nh j u i) |
| intro j hi |
| rw [s.d.vscale,abs_of_nonneg (by positivity)] |
| calc _ ≤ _ := mul_le_mul_of_nonneg_left (s.nh_ub h hi) (by positivity) |
| _ ≤ _ := by linarith [mul_le_mul_of_nonneg_left (cyclone hi) h.pos] |
|
|
| lemma rim_ub {p M} (h:s.Works p M) : |
| s.d.von s.rim ≤32*2*p*box s.b := by |
| have hl : s.L-1<s.L := by have := h.len; omega |
| unfold rim; rw [s.d.vscale]; norm_num |
| have ht := s.mh_ub h hl |
| have he : liftB s.b s.L (s.L-1)=box s.b := by unfold liftB; rw [gap_end,mul_one] |
| rw [he] at ht; linarith |
|
|
| lemma march_ub {p M} (h:s.Works p M) : |
| s.d.von s.march ≤ hefty M*2*p*2 := by |
| have hp:=h.pos; have hM : 0 ≤ hefty M := by unfold hefty; linarith [h.mass] |
| apply s.vgeo (by positivity) (f:=s.trail) |
| intro i hi |
| unfold trail |
| apply le_trans (s.d.vseries (fun k u j=>(32:ℝ)^(s.L-k)*s.chipV i (s.mh k) u j) (Ico i s.L)) |
| let W (k : ℕ) := (32:ℝ)^(s.L-k) |
| have hh (k) (hk:k∈Ico i s.L) : |
| s.d.von (fun u j=>W k*s.chipV i (s.mh k) u j) ≤ |
| (hefty M*2*p)*(s.fc i)*(W k*liftB s.b s.L k) := by |
| have h0 : 0≤W k := by unfold W; positivity |
| rw [s.d.vscale,abs_of_nonneg h0] |
| apply le_trans (mul_le_mul_of_nonneg_left (s.masked_ub h i k (mem_Ico.1 hk).2) h0) |
| exact le_of_eq (by ring) |
| apply (sum_le_sum hh).trans |
| rw [← mul_sum, mul_assoc] |
| exact mul_le_mul_of_nonneg_left (firm_tail s.b s.K s.L i hi) (by positivity) |
|
|
| def Bprice (b : ℕ) (M : ℝ) := |
| droplets*2+hefty M*2*2+32*2*box b+2+64*2 |
| lemma bprice_pos {M : ℝ} (h:1≤M) (b) : 0 < Bprice b M := by |
| have hs:=smallp; have hb:=box0 b |
| unfold Bprice droplets hefty |
| have :0<M := by linarith |
| positivity |
| lemma subtotal {p M} (h:s.Works p M) : |
| s.d.von s.sumB ≤ Bprice s.b M*p := by |
| let c : Vertex n w :=fun u i=> s.clouds u i+s.march u i |
| let a : Vertex n w :=fun u i=> c u i+s.rim u i |
| let b : Vertex n w :=fun u i=> a u i+s.thunder u i |
| apply le_trans (s.d.vplus b s.beasts) |
| have h1 : s.d.von b ≤ s.d.von a+s.d.von s.thunder:= s.d.vplus a s.thunder |
| have h2 : s.d.von a ≤ s.d.von c+s.d.von s.rim:=s.d.vplus c s.rim |
| have h3 : s.d.von c ≤ s.d.von s.clouds+s.d.von s.march:=s.d.vplus s.clouds s.march |
| have h4:=s.thunder_ub h; have h5:=s.march_ub h; have h6:=s.droplets_ub h |
| have h7:=s.rim_ub h; have h8:=s.beasts_ub h |
| unfold Bprice; linarith |
|
|
| lemma charge_pos (C : ℝ) (h:1≤C) : 0≤Run.charge C := by |
| unfold Run.charge Run.wideK |
| have :0≤C:=by linarith |
| positivity |
| def localP (K b : ℕ) (C M : ℝ) := |
| (1+2*K:ℝ)*Run.charge C*Bprice b M |
|
|
| set_option maxHeartbeats 500000 in |
| /-- Integrated buffered row estimate. -/ |
| theorem compress {p M theta C f} (h:s.Works p M) (hf:TS theta C f) |
| (hz:delta≤theta) (hc:theta≤1) : |
| s.d.ton (s.diff f) ≤localP s.K s.b C M*p := by |
| let g:= s.diff f |
| let c:=Run.charge C |
| let u:Vertex n w:=fun s' i=> (1+2*s.K:ℝ)*c*s.sumB s' i |
| have hcp : 0≤c := charge_pos C hf.start.one |
| have hd (u i k : ℝ) (hi:0≤k) : u≤ i → k*u≤k*i := fun e => mul_le_mul_of_nonneg_left e hi |
| have hv := s.sumB_nn |
| have hh (w' i) (hi:i∈s.src0 w') : |
| ∑ j∈s.dst0 w',g w' i j^4≤u w' i^4 := by |
| let b:= c*s.sumB w' i |
| let r:=s.go w' i |
| let F (v : Blob) := r.S.filter fun j=>v.val r.S r.K f j≠0 |
| let t:=(F (r.mid r.L) ∪ F r.origin) |
| have hs: t⊆s.dst0 w':= union_subset (filter_subset ..) (filter_subset ..) |
| have he : ∑ j∈s.dst0 w',g w' i j^4=∑ j∈t,g w' i j^4 := by |
| symm; apply sum_subset hs |
| intro j hj hz |
| have h1 : j ∈ r.S :=hj |
| have ha : (r.mid r.L).val r.S r.K f j=0 := by |
| by_contra e; exact hz (mem_union_left _ (mem_filter.mpr ⟨h1,e⟩)) |
| have hb : r.origin.val r.S r.K f j=0 := by |
| by_contra e; exact hz (mem_union_right _ (mem_filter.mpr ⟨h1,e⟩)) |
| change (fourth ((r.mid r.L).val r.S r.K f j)-fourth (r.origin.val r.S r.K f j))^4=0 |
| rw [ha,hb]; norm_num |
| have hk (v) : (F v).card≤ s.K:=Blob.support_size hf (lt_of_lt_of_le dp hz) _ _ _ |
| have hcard : t.card≤2*s.K := |
| le_trans (card_union_le ..) (by linarith [hk (r.mid r.L),hk r.origin]) |
| have hc1 : (t.card:ℝ)≤2*(s.K:ℝ) := by exact_mod_cast hcard |
| have hc2 : (t.card:ℝ) ≤ (1+2*s.K:ℝ)^4 := by |
| let v:ℝ:=2*s.K |
| change (t.card:ℝ) ≤ (1+v)^4 |
| change (t.card:ℝ)≤v at hc1 |
| have hz : 0≤v:=by dsimp only [v]; positivity |
| nlinarith [sq_nonneg v] |
| calc _ = _:=he |
| _ ≤ ∑ j∈t,b^4 := |
| sum_le_sum fun j hj=> by rw [← Meter.abs4]; |
| exact pow_le_pow_left₀ (abs_nonneg _) (s.receipt h hf hz hc hi (hs hj)) _ |
| _ = (t.card:ℝ)*b^4 := by simp |
| _ ≤ (1+2*s.K:ℝ)^4*b^4 := mul_le_mul_of_nonneg_right hc2 (by positivity) |
| _ = _ := by unfold b u; ring |
| have hg : s.d.ton g ≤ s.d.von u := |
| (s.d.tm_le (s.d.vn0 _)).2 (by rw [s.d.von_four]; exact s.d.vi_mono hh) |
| apply hg.trans |
| unfold u; rw [s.d.vscale,abs_of_nonneg (by positivity)] |
| have hl:= hd _ _ ((1+2*s.K:ℝ)*Run.charge C) (by change 0≤(1+2*s.K:ℝ)*c; positivity) |
| (s.subtotal h) |
| unfold localP c; linarith |
|
|
| end Spray |
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| section |
|
|
| set_option synthInstance.maxSize 4096 |
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis Hie At Buf Finset |
|
|
| namespace Flame |
| variable {n : ℕ} [Fact n.Prime] |
|
|
| def spill (s : Stair) (d : Axis) (a : ℕ) (K : ℕ) (v w : Flame n) : Spray n 0 := |
| let p:=d.narrowed a |
| let tint (i : ℕ) := fun (q:Pool n) x y=> |w.smoke s p (i+1) q x y| |
| let fog:=fun i q x y=> |v.smoke s d (i+1) q x y| + d.wmask a (tint i) q x y |
| { d:=d,t:=a,L:=s.L,K:=K,b:=2 |
| a:=v.lamp,q:=w.lamp |
| inc:=fun i q x y=>(v.bundle s d i q x y,w.bundle s p i q x y) |
| lead:=v.picture s d true,seedB:=w.picture s p false,fog:=fog } |
|
|
| lemma exact1 (s d a K) (v w : Flame n) (i q x y) |
| (hx:x∈src d.S d.u q) (hy:y∈dst d.S d.a q) : |
| (((spill s d a K v w).go q x).pile i y).1=v.prefixR s d i q x y := by |
| induction i with |
| | zero=>rw [v.prefix0]; rfl |
| | succ i ih=> |
| rw [← v.next s d]; rw [Run.pile]; rw [Pi.add_apply,Prod.fst_add,ih] |
| congr 1 |
| change v.bundle _ _ _ _ _ _=_ |
| unfold bundle; rw [ite_eq_left ⟨hx,hy⟩] |
|
|
| lemma exact2 (s d a K) (v w : Flame n) (i q x y) (hx:x∈src d.S d.u q) : |
| (((spill s d a K v w).go q x).pile i y).2= |
| d.wmask a (w.prefixR s (d.narrowed a) i) q x y := by |
| induction i with |
| | zero=> rw [Axis.wmask, w.prefix0]; split <;> rfl |
| | succ i ih=> |
| rw [Run.pile,Pi.add_apply,Prod.snd_add,ih] |
| change _+w.bundle s (d.narrowed a) i q x y=_ |
| unfold bundle Axis.wmask |
| by_cases h:y∈dst d.S a q |
| · simp only [Axis.narrowed,hx,h,and_self,ite_true] |
| exact w.next s (d.narrowed a) i q x y |
| · simp [h] |
|
|
| lemma outputcard (p q : ℝ) : min 1 (max p q) = max (min 1 p) (min 1 q) := by grind |
|
|
| set_option maxHeartbeats 500000 in |
| lemma earliestCost {s d a K c} {v w : Flame n} (h1:Owes s d true c v) (h2:Owes s (d.narrowed a) false c w) |
| (j) (q x y) (hx:x∈src d.S d.u q) (hy:y∈dst d.S d.a q) : |
| ((spill s d a K v w).go q x).epi j y≤(spill s d a K v w).pay j q x y := by |
| have hi : x∈d.S := (mem_filter.mp hx).1 |
| have hh : y∈d.S := (mem_filter.mp hy).1 |
| let r:=d.narrowed a |
| let C (f:Flame n) (d : Axis) := f.prefixR s d (j+1) q x y-f.lamp x y |
| have e1:v.picture s d true j x y+|v.smoke s d (j+1) q x y|≥ rel (C v d) (v.lamp x y) := |
| v.tip_noise h1 j q hi hh |
| have e2:w.picture s r false j x y+|w.smoke s r (j+1) q x y|≥ |C w r| := |
| w.tip_noise h2 j q hi hh |
| have he : 0≤ rel (C v d) (v.lamp x y) := rel_nn (h1.positive x hi y hh) |
| simp only [Run.epi,outputcard,exact1 s d a K v w _ q x y hx hy,exact2 s d a K v w _ q x y hx] |
| simp only [Spray.pay,Spray.s1,Spray.s2,spill,Spray.go,Spray.dst1,Axis.wmask] |
| by_cases hz:y∈dst d.S a q |
| · simp only [hz,ite_true]; unfold C r at *; unfold rel at * |
| grind |
| · simp only [hz,ite_false,sub_self,abs_zero] |
| unfold C r at *; unfold rel at *; grind |
|
|
| lemma ready {s : Stair} {d K a c M} {v w : Flame n} |
| (hv : Owes s d true c v) (hw : Owes s (d.narrowed a) false c w) |
| (hm:1≤M) (hl : legal n d.S) (hq : d.a≤a) (hz:2^d.a≤n) |
| (hs : ∀ i∈d.S,∀ j∈d.S, |w.lamp i j|≤zeta ∧ (v.lamp i j ≤ At.small → w.lamp i j=0)) |
| (ht : ∀ i∈d.S,(∑ j∈d.S,v.lamp i j)*rate d.a≤ M) : |
| (spill s d a K v w).Works (2*contract s c) M := by |
| let z:=contract s c |
| have hh : 0≤ z:=protocol |
| have he (j) : z*liftB 2 s.L j≤2*contract s c*liftB 2 s.L j := by |
| apply mul_le_mul_of_nonneg_right (show z≤2*z by linarith) (le_trans zero_le_one (lift_one ..)) |
| refine ⟨show 0≤2*z by positivity,hm,s.length_pos,hl,hq,hz, |
| fun i hi j hj=> ⟨hv.positive i hi j hj,hs i hi j hj⟩,ht, |
| fun i _ u j hj k hk=> earliestCost hv hw i _ _ _ hj hk,?_,?_,?_⟩ |
| · intro j _ |
| exact le_trans (v.pink hv j) (he j) |
| · intro j _ |
| change d.ton (d.wmask a _)≤_ |
| rw [d.tmask _ hq] |
| exact le_trans (w.pink hw j) (he j) |
| · intro j _ |
| let f:Pics n:=fun u x y=> |v.smoke s d (j+1) u x y| |
| let g:Pics n:=fun u x y=> |w.smoke s (d.narrowed a) (j+1) u x y| |
| apply le_trans (d.tplus f (d.wmask a g)) |
| unfold f g; rw [d.ton_subnorm,d.tmask a hq, Axis.ton_subnorm] |
| change _≤ _*decay s.L j |
| linarith [v.fumes hv j,w.fumes hw j] |
|
|
| end Flame |
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Est |
| noncomputable section |
| open Analysis Hie At Buf Finset |
| set_option synthInstance.maxSize 4096 |
|
|
| variable {n : ℕ} [Fact n.Prime] |
| /-- Use only diagonal of a picture as one vertex. Y conditioned |
| nominally at rate 1, also pin at the diagonal for the mix. -/ |
| def ridge (f : Vec) : Mat := fun x y=> if x=y then f x else 0 |
| def core (f : Paint n) : Pics n := fun s=>ridge (f s) |
| def diagP (f : Pics n) : Paint n := fun s x=> f s x x |
|
|
| namespace Axis |
| variable (d : Axis) |
| lemma diagh {f : Paint n} (x y : ℕ) : |
| (d.narrowed 0).fm (core f) x y=ridge (d.vm f) x y := by |
| have he (p : ℕ) : |
| pct n d.u * (pct n 0) * Env.cond d.u 0 (x:ZMod n) (p:ZMod n) (w:=0) |
| (fun s=>f s x) = |
| av (fun s:Pool n=> if hit d.u (x:ZMod n) s.1 then f s x else 0) := by |
| rw [← Env.two_cond]; simp only [Env.mask,allhit,and_true] |
| by_cases ht:x=y |
| · simp only [fm,core,vm,ridge,ht,ite_true] |
| subst y |
| apply mul_left_cancel₀ (mul_pos (pct_pos (NeZero.pos n) d.u) (pct_pos (NeZero.pos n) 0)).ne' |
| simpa only [Nat.cast_zero] using Eq.trans (he x) (he 0).symm |
| · simp only [fm,core,ridge,ht,ite_false] |
| unfold Env.cond; rw [av_zero] |
|
|
| lemma diagonal (f : Paint n) : |
| (d.narrowed 0).ton (core f)=d.von f := by |
| conv_lhs=> rw [← four_fourth ((d.narrowed 0).tn0 _),ton_four] |
| conv_rhs=> rw [← four_fourth (d.vn0 _),von_four] |
| congr 1; rw [ti_apply,vi_apply]; dsimp only [narrowed] |
| congr 1 |
| apply congrArg av; ext s |
| apply sum_congr rfl; intro i hi |
| have hg:i∈dst d.S 0 s:=mem_filter.2 ⟨(mem_filter.1 hi).1,allhit ..⟩ |
| rw [sum_eq_single i] |
| · simp [core,ridge] |
| · intro j hj ht |
| simp only [core,ridge,Ne.symm ht,↓reduceIte]; norm_num |
| simp [hg] |
|
|
| lemma vproject (f : Pics n) : |
| d.von (diagP f) ≤ (d.narrowed 0).ton f := by |
| apply (d.vm_le ((d.narrowed 0).tn0 f)).2 |
| rw [ton_four]; apply d.vi_mono |
| intro s x hx |
| have ht : x∈dst d.S 0 s:= mem_filter.2 ⟨(mem_filter.1 hx).1,allhit ..⟩ |
| exact single_le_sum (f:=fun j=> f s x j^4) (fun _ _=>by positivity) ht |
|
|
| def color (s:Stair) (v:Flame n) : Paint n := |
| fun u i => if i∈src d.S d.u u then smooth (v.prefixR s (d.narrowed 0) s.L u i i) else 0 |
| lemma boundsC (s v u i) : in01 (d.color (n:=n) s v u i) := by |
| unfold color; split; exact unit_mem _ |
| unfold in01; norm_num |
|
|
| /- the group 1 slack answer of a vector flame. -/ |
| lemma drawn {s : Stair} {v:Flame n} {c : ℝ} (h : v.Owes s (d.narrowed 0) false c) |
| {f : Vec} (hf:∀ x∈d.S,in01 (f x)) (he:∀ x∈d.S,v.lamp x x=f x) : |
| d.von (fun u i=>d.color s v u i-f i) ≤ 6*Flame.contract s c := by |
| let b := d.narrowed 0 |
| let i:=s.L-1 |
| have hs : i+1=s.L := by have :=s.length_pos; dsimp only [i]; omega |
| let P : Pics n := fun _=> v.picture s b false i |
| let q:=v.smoke s b (i+1) |
| let t : Pics n := fun u x y=> P u x y+|q u x y| |
| have hp : d.von (fun u i=>d.color s v u i-f i)≤d.von (diagP t) := by |
| apply d.vorder |
| intro u x hx |
| have he1 := (mem_filter.1 hx).1 |
| have hu:=v.tip_noise h i u he1 he1; change |_ - v.lamp x x|≤ t u x x at hu |
| change |d.color s v u x-f x|≤ t u x x |
| have hh := hf x he1 |
| have hv : smooth (f x)=f x := by |
| unfold smooth in01 at *; grind |
| unfold color; rw [ite_eq_left hx] |
| refine le_trans (b:=|v.prefixR s b (i+1) u x x - f x|) ?_ ?_ |
| · rw [hs] |
| conv_lhs=> rhs; rw [← hv] |
| have hg := unit_ic.lip (f x) (v.prefixR s b s.L u x x) |
| rwa [one_mul] at hg |
| simpa only [he x he1] using hu |
| apply (hp.trans (d.vproject _)).trans |
| apply (b.tplus P (fun u x y=> |q u x y|)).trans |
| rw [b.ton_subnorm] |
| have ht:=v.pink h i; have hz:=v.fumes h i |
| let k:=Flame.contract s c |
| change b.ton P ≤ k* liftB _ _ _ at ht |
| change b.ton q≤ k*_ at hz |
| have hl : liftB 2 s.L i=4 := by unfold liftB i; rw [gap_end]; norm_num [box] |
| have hh : decay s.L i≤1:=dry_one _ |
| rw [hl] at ht |
| have hkp :0≤k:=Flame.protocol |
| change _≤6*k |
| nlinarith |
|
|
| end Axis |
| end |
| end ExactDerandomization.Est |
|
|
| end |
|
|
| end OAI |
|
|
