| import Mathlib |
| import OAI.Probability.SKBarriers.Dynamics.GreedyStep |
| import OAI.Probability.SKBarriers.Dynamics.GreedyRecursion |
|
|
| namespace OAI |
|
|
| section |
|
|
| noncomputable section |
| open scoped BigOperators |
| open MeasureTheory ProbabilityTheory Filter Set |
| namespace SK.Analytic |
|
|
| theorem greedy_marker_windows {n : ℕ} (hn : 0 < n) (μ : ProbabilityMeasure ℝ) |
| (pool : ℕ → Finset (Config n)) (fallback : ℕ → Config n) |
| (hf : ∀ j, fallback j ∈ pool j) (base : ℕ → Config n) (x : ℕ → Config n) |
| (r : ℕ → ℝ) (B H p m : ℕ) (t ρ d b b' q : ℝ) |
| (hp : 0 < p) (hB : 0 < B) (hHB : H < B) (hH : ⌈2/b^2⌉₊ ≤ H) |
| (ht : 0 < t) (hρ : 0 < ρ) (hd : 0 ≤ d) (hb : 0 < b) |
| (hpack : 3*t < b^2/2) (hcsmall : 3*t < b) (hEst : 6*p*ρ^20 < t) |
| (hsmall' : 2*t+6*p*ρ^20+2*(n:ℝ)^(-(1:ℝ)/100) < b') |
| (hsep' : 12*p*ρ^20+4*(n:ℝ)^(-(1:ℝ)/100) < 3*ρ) |
| (hwidth : ρ^8 < t/2) |
| (hsmall : 6*p*ρ^20+2*(n:ℝ)^(-(1:ℝ)/100)+ρ^20+d/2 < ρ^8) |
| (hsep : 6*p*ρ^20+2*(n:ℝ)^(-(1:ℝ)/100)+ρ^20+3*d/2 ≤ 2*ρ) |
| (hd' : d/2 ≤ ρ^20) (heta : 2*(n:ℝ)^(-(1:ℝ)/100) < 2*ρ^20) |
| (hq : 2*t+6*p*ρ^20+2*(n:ℝ)^(-(1:ℝ)/100)+2*ρ^20 < q) |
| (hr : ∀ i < p, r i ∈ Icc t (2*t)) |
| (hspacing : ∀ i j, i < j → j < p → 3*ρ ≤ r j-r i) |
| (hmass : ∀ i < p, (μ : Measure ℝ).real (Icc (r i-2*ρ^8) (r i+2*ρ^8)) ≤ ρ^4) |
| (hjump : ∀ z k, k < m → |overlap z (x (k+1))-overlap z (x k)| ≤ d) |
| (hcoverage : ∀ j < p, ∀ v : ℕ → Config n, (∀ i < j, v i ∈ pool i) → |
| ∀ u ≤ m, (∀ i, j/B*B ≤ i → i < j → |overlap (v i) (x u)| ≤ 3*t) → |
| ∃ w ∈ pool j, q ≤ overlap w (x u) ∧ |
| ∀ i, j/B*B ≤ i → i < j → |overlap (v i) w| ≤ 3*t) |
| (hsigned : ∀ i j, i < j → j < p → ∀ v ∈ pool i, ∀ w ∈ pool j, ∀ k ≤ m, |
| (![v,w,x k] : ReplicaConfig n 3) ∉ signedLockingSet n q b) |
| (hbank : ∀ i k j, i < k → k < j → j < p → ∀ v ∈ pool i, ∀ z ∈ pool k, ∀ w ∈ pool j, |
| (![z,v,w] : ReplicaConfig n 3) ∉ signedLockingSet n b b' ∧ |
| (![z,v,flip w] : ReplicaConfig n 3) ∉ signedLockingSet n b b') |
| (hnarrow : ∀ i j, i < j → j < p → ∀ v ∈ pool i, ∀ w ∈ pool j, ∀ k ≤ m, |
| (![v,x k,w] : ReplicaConfig n 3) ∉ narrowLockingSet n μ t ρ) |
| (hpass : overlap (bankPick pool fallback B x t q 0 base 0) (x m) ≤ 0) : |
| ∃ k ≤ m, ∀ a, a*B < p → |
| |overlap (greedyReference base (bankPick pool fallback B x t q) x r b m (a*B)) (x k)-r (a*B)| ≤ 6*p*ρ^20 := by |
| classical |
| let pick := bankPick pool fallback B x t q |
| let S := greedyRun base pick x r b m |
| have hε : 0 < ρ^20 := pow_pos hρ _ |
| have hη : 0 ≤ 2*(n:ℝ)^(-(1:ℝ)/100) := by positivity |
| have htwo : 2*t < q := by |
| have hEp : 0 ≤ 6*(p:ℝ)*ρ^20 := by positivity |
| linarith only [hq,hEp,hε,hη] |
| have hmem (j i : ℕ) (hi : i < j) : (S j).refs i ∈ pool i := by |
| rw [show (S j).refs i=greedyReference base pick x r b m i from greedyRun_refs _ _ _ _ _ _ _ _ hi] |
| exact bankPick_mem pool fallback hf B x t q i _ _ |
| have hfirst := bankPick_spec pool fallback B x t q 0 base 0 |
| (hcoverage 0 hp base (by intros; omega) 0 (by omega) (by intros; omega)) |
| have hanchor (j : ℕ) (hj : 0 < j) : q ≤ overlap ((S j).refs 0) (x 0) := by |
| rw [show (S j).refs 0=greedyReference base pick x r b m 0 from greedyRun_refs _ _ _ _ _ _ _ _ hj] |
| exact hfirst.1 |
| have HI : ∀ j ≤ p, (S j).time ≤ m ∧ BlockProtected B j (S j).kept ∧ |
| (∀ i ∈ (S j).kept, |overlap ((S j).refs i) (x (S j).time)-r i| ≤ 6*j*ρ^20) ∧ |
| (∀ i ∈ (S j).kept, ∀ k ∈ (S j).kept, i < k → |
| |overlap ((S j).refs i) ((S j).refs k)-r i| ≤ 6*j*ρ^20) := by |
| intro j hjp |
| induction j with |
| | zero => simp [S,greedyRun,BlockProtected] |
| | succ j ih => |
| have hjp' : j < p := by omega |
| obtain ⟨hτ,hblock,hpath,hpair⟩ := ih (by omega) |
| have hEr : 6*(j:ℝ)*ρ^20 ≤ 6*p*ρ^20 := by gcongr |
| have hA := greedyRun_range base pick x r b m j |
| have hcand := hcoverage j hjp' (S j).refs (hmem j) (S j).time hτ (by |
| intro i hil hij |
| have hlo : (j-1)/B*B ≤ j/B*B := Nat.mul_le_mul_right B (Nat.div_le_div_right (Nat.sub_le j 1)) |
| have himem := hblock.1 i (hlo.trans hil) hij |
| have hh := hpath i himem |
| have hri := hr i (hij.trans hjp') |
| have hh' := abs_add_le (overlap ((S j).refs i) (x (S j).time)-r i) (r i) |
| rw [sub_add_cancel,abs_of_pos (ht.trans_le hri.1)] at hh' |
| linarith only [hh',hh,hri.2,hEr,hEst]) |
| have hsel := bankPick_spec pool fallback B x t q j (S j).refs (S j).time hcand |
| let w := pick j (S j).refs (S j).time |
| have hw : w ∈ pool j := bankPick_mem pool fallback hf B x t q j _ _ |
| by_cases hj0 : j=0 |
| · subst j |
| have hband := firstCrossing_band (fun k => overlap w (x k)) (r 0) d m |
| (by change r 0 < overlap (bankPick pool fallback B x t q 0 base 0) (x 0); linarith only [hfirst.1,(hr 0 hp).2,htwo]) |
| (by change overlap (bankPick pool fallback B x t q 0 base 0) (x m) ≤ r 0; linarith only [hpass,(hr 0 hp).1,ht]) |
| (hjump w) |
| dsimp [w, S, greedyRun] at hband |
| change _ ≤ m ∧ _ ∧ _ ∧ _ |
| simp only [S,greedyRun,zero_add,Nat.cast_one,mul_one] |
| simp only [Finset.empty_sdiff,Finset.insert_empty,Finset.mem_singleton,ite_true] |
| refine ⟨hband.1,?_,?_,?_⟩ |
| · constructor |
| · intro i _ hi |
| have : i=0 := by omega |
| simpa only [Finset.mem_singleton] using this |
| · intro k hk |
| have : k*B=0 := by omega |
| simpa only [Finset.mem_singleton] using this |
| · intro i hi |
| subst i |
| simp only [Function.update_self] |
| rw [abs_le] |
| constructor <;> linarith only [hband.2.1,hband.2.2,hd',hε] |
| · intro i hi k hk hik |
| omega |
| · have hj : 0 < j := Nat.pos_of_ne_zero hj0 |
| have Hstep := greedy_locking_step hn μ (S j).refs w x (S j).kept r B H j (S j).time |
| t ρ (6*j*ρ^20) d b b' q hj hB hHB hH ht hρ (by positivity) hd hb hpack hcsmall |
| (hEr.trans_lt hEst) (by linarith only [hsmall',hEr]) (by linarith only [hsep',hEr]) hwidth |
| (by linarith only [hsmall,hEr]) (by linarith only [hsep,hEr]) hd' heta |
| (by linarith only [hq,hEr]) (fun i hi => hr i (hi.trans_lt hjp')) |
| (fun i k hik hk => hspacing i k hik (hk.trans_lt hjp')) (fun i hi => hmass i (hi.trans hjp')) |
| hA hblock hpath hpair (hanchor j hj) hsel.1 |
| (by |
| intro hmod |
| apply hsel.2 (j-1) _ (by omega) |
| have hh : j%B+j/B*B=j := by simpa only [Nat.mul_comm B] using Nat.mod_add_div j B |
| have hpos : 0 < j%B := Nat.pos_of_ne_zero hmod |
| omega) |
| (fun z k hk => hjump z k (hk.trans_le hτ)) |
| (fun i hi => hsigned i j (hA i hi) hjp' _ (hmem j i (hA i hi)) w hw _ hτ) |
| (fun i hi k hk hik => hbank i k j hik (hA k hk) hjp' _ (hmem j i (hA i hi)) _ (hmem j k (hA k hk)) w hw) |
| (fun i hi k hk => hnarrow i j (hA i hi) hjp' _ (hmem j i (hA i hi)) w hw k (hk.trans hτ)) |
| obtain ⟨hs,hcard,hprot,hzero,htime,hband,href,hnewpath⟩ := Hstep |
| have hinc : 6*(j:ℝ)*ρ^20+2*(n:ℝ)^(-(1:ℝ)/100)+2*ρ^20 ≤ 6*(j+1:ℕ)*ρ^20 := by |
| simp only [Nat.cast_add,Nat.cast_one] |
| nlinarith only [heta,hε] |
| have hmono : 6*(j:ℝ)*ρ^20 ≤ 6*(j+1:ℕ)*ρ^20 := by |
| simp only [Nat.cast_add,Nat.cast_one]; nlinarith only [hε] |
| change _ ≤ m ∧ _ ∧ _ ∧ _ |
| simp only [S,greedyRun,ite_eq_right hj0] |
| refine ⟨htime.trans hτ,hprot,?_,?_⟩ |
| · intro i hi |
| rcases Finset.mem_insert.mp hi with he | hi |
| · subst i |
| rw [Function.update_self,abs_le] |
| have hc : 2*ρ^20 ≤ 6*(j+1:ℕ)*ρ^20 := by |
| have hjr : (0:ℝ) ≤ j := by positivity |
| simp only [Nat.cast_add,Nat.cast_one]; nlinarith only [mul_nonneg hjr hε.le,hε] |
| constructor <;> linarith only [hband.1,hband.2,hd',hc] |
| · have him : i ∈ (S j).kept := (Finset.mem_sdiff.mp hi).1 |
| rw [Function.update_of_ne (ne_of_lt (hA i him))] |
| exact (hnewpath i hi).trans hinc |
| · intro i hi k hk hik |
| have hil : i < j := by |
| rcases Finset.mem_insert.mp hk with rfl | hk |
| · exact hik |
| · exact hik.trans (hA k (Finset.mem_sdiff.mp hk).1) |
| have him : i ∈ (S j).kept\(S j).kept.filter (fun i => b < |overlap ((S j).refs i) w|) := by |
| exact (Finset.mem_insert.mp hi).resolve_left (ne_of_lt hil) |
| rw [Function.update_of_ne (ne_of_lt hil)] |
| rcases Finset.mem_insert.mp hk with rfl | hk |
| · rw [Function.update_self] |
| exact (href i him).trans (by linarith only [hinc,hε]) |
| · have hkl := hA k (Finset.mem_sdiff.mp hk).1 |
| rw [Function.update_of_ne (ne_of_lt hkl)] |
| exact (hpair i (Finset.mem_sdiff.mp him).1 k (Finset.mem_sdiff.mp hk).1 hik).trans hmono |
| obtain ⟨hτ,hprotected,hpath,_⟩ := HI p le_rfl |
| refine ⟨(S p).time,hτ,?_⟩ |
| intro a ha |
| have hmem := hprotected.2 a ha |
| rw [← greedyRun_refs base pick x r b m p (a*B) ha] |
| exact hpath (a*B) hmem |
|
|
| end SK.Analytic |
|
|
| end |
| end |
|
|
| end OAI |
|
|
