| import Mathlib |
| import OAI.Probability.SKBarriers.Dynamics.GreedyInvariant |
| import OAI.Probability.SKBarriers.Dynamics.PredictableGrid |
|
|
| namespace OAI |
|
|
| section |
|
|
| noncomputable section |
| open scoped BigOperators |
| open Classical MeasureTheory Set |
| namespace SK.Analytic |
|
|
| structure GreedyScaleBounds (n B H p : ℕ) (t ρ d b b' q : ℝ) : Prop where |
| p_pos : 0<p |
| B_pos : 0<B |
| HB : H<B |
| packingH : ⌈2/b^2⌉₊≤H |
| t_pos : 0<t |
| rho_pos : 0<ρ |
| d_nonneg : 0≤d |
| b_pos : 0<b |
| packing : 3*t<b^2/2 |
| cutoff : 3*t<b |
| total_error : 6*p*ρ^20<t |
| small_cutoff : 2*t+6*p*ρ^20+2*(n:ℝ)^(-(1:ℝ)/100)<b' |
| separation : 12*p*ρ^20+4*(n:ℝ)^(-(1:ℝ)/100)<3*ρ |
| width : ρ^8<t/2 |
| small_width : 6*p*ρ^20+2*(n:ℝ)^(-(1:ℝ)/100)+ρ^20+d/2<ρ^8 |
| large_width : 6*p*ρ^20+2*(n:ℝ)^(-(1:ℝ)/100)+ρ^20+3*d/2≤2*ρ |
| jump : d/2≤ρ^20 |
| eta : 2*(n:ℝ)^(-(1:ℝ)/100)<2*ρ^20 |
| high : 2*t+6*p*ρ^20+2*(n:ℝ)^(-(1:ℝ)/100)+2*ρ^20<q |
| grid_range : 4*p*ρ≤t |
|
|
| theorem gridThresholds_range {n p : ℕ} (hn : 0<n) {t ρ : ℝ} (hρ : 0<ρ) |
| (hp : 4*p*ρ≤t) (z : Fin p → Fin n) : ∀i<p,gridThresholds n p t ρ z i∈Icc t (2*t) := by |
| intro i hi |
| rw [gridThresholds,dite_eq_left hi] |
| have H := thresholdGrid_mem hn hρ (t+4*i*ρ) (z ⟨i,hi⟩) |
| have hiR : (i:ℝ)+1≤p := by exact_mod_cast hi |
| have h0 : 0≤4*(i:ℝ)*ρ := by positivity |
| have h1 : 4*(i:ℝ)*ρ+ρ≤4*p*ρ := by nlinarith only [mul_nonneg (show 0≤(p:ℝ)-i-1 by linarith only [hiR]) hρ.le,hρ] |
| constructor <;> linarith only [H.1,H.2,h0,h1,hp] |
|
|
| theorem gridThresholds_spacing {n p : ℕ} (hn : 0<n) {t ρ : ℝ} (hρ : 0<ρ) |
| (z : Fin p → Fin n) : ∀i j,i<j → j<p → 3*ρ≤gridThresholds n p t ρ z j-gridThresholds n p t ρ z i := by |
| intro i j hij hj |
| rw [gridThresholds,dite_eq_left hj,gridThresholds,dite_eq_left (hij.trans hj)] |
| have Hi := thresholdGrid_mem hn hρ (t+4*i*ρ) (z ⟨i,hij.trans hj⟩) |
| have Hj := thresholdGrid_mem hn hρ (t+4*j*ρ) (z ⟨j,hj⟩) |
| have hR : (i:ℝ)+1≤j := by exact_mod_cast hij |
| have hM := mul_nonneg (show 0≤(j:ℝ)-i-1 by linarith only [hR]) hρ.le |
| nlinarith only [Hi.2,Hj.1,hM] |
|
|
| theorem greedy_no_passage {n : ℕ} (hn : 0<n) (μ : ProbabilityMeasure ℝ) |
| (pool : ℕ → Finset (Config n)) (fallback : ℕ → Config n) |
| (hf : ∀j,fallback j∈pool j) (base : ℕ → Config n) (x : ℕ → Config n) |
| (B H s m : ℕ) (t ρ d b b' q : ℝ) (G : GreedyScaleBounds n B H (B*s) t ρ d b b' q) |
| (hcount : (B*s)*((4*ρ^8/ρ+1/(n:ℝ))/ρ^4)+(m+1)*(2*(6*(B*s)*ρ^20)/ρ+1/(n:ℝ))^s<1) |
| (hjump : ∀ z k, k < m → |overlap z (x (k+1))-overlap z (x k)|≤d) |
| (hcoverage : ∀ j < B*s,∀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<B*s → ∀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<B*s → ∀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<B*s → ∀v∈pool i,∀w∈pool j,∀ k ≤ m, |
| (![v,x k,w] : ReplicaConfig n 3)∉narrowLockingSet n μ t ρ) : |
| 0<overlap (bankPick pool fallback B x t q 0 base 0) (x m) := by |
| by_contra hpos |
| have hpass : overlap (bankPick pool fallback B x t q 0 base 0) (x m)≤0 := le_of_not_gt hpos |
| let p := B*s |
| let P := (FiniteLaw.uniformFin n hn).iid (Fin p) |
| let bad (z : Fin p → Fin n) := ∃i : Fin p,ρ^4 < (μ:Measure ℝ).real |
| (Icc (thresholdGrid n (t+4*i.val*ρ) ρ (z i)-2*ρ^8) (thresholdGrid n (t+4*i.val*ρ) ρ (z i)+2*ρ^8)) |
| let W (k : Fin (m+1)) (z : Fin p → Fin n) := ∀i : Fin p,i.val%B=0 → |
| |overlap (greedyReference base (bankPick pool fallback B x t q) x (gridThresholds n p t ρ z) b m i.val) (x k.val)- |
| thresholdGrid n (t+4*i.val*ρ) ρ (z i)|≤6*p*ρ^20 |
| have hall : ∀z,bad z ∨ ∃k : Fin (m+1),W k z := by |
| intro z |
| by_cases hz : bad z |
| · exact Or.inl hz |
| · right |
| have hm : ∀i<p,(μ:Measure ℝ).real (Icc (gridThresholds n p t ρ z i-2*ρ^8) (gridThresholds n p t ρ z i+2*ρ^8))≤ρ^4 := by |
| intro i hi |
| rw [gridThresholds,dite_eq_left hi] |
| exact le_of_not_gt (fun H => hz ⟨⟨i,hi⟩,H⟩) |
| obtain ⟨k,hk,Hk⟩ := greedy_marker_windows hn μ pool fallback hf base x (gridThresholds n p t ρ z) |
| B H p m t ρ d b b' q G.p_pos G.B_pos G.HB G.packingH G.t_pos G.rho_pos G.d_nonneg G.b_pos |
| G.packing G.cutoff G.total_error G.small_cutoff G.separation G.width G.small_width G.large_width |
| G.jump G.eta G.high (gridThresholds_range hn G.rho_pos G.grid_range z) |
| (gridThresholds_spacing hn G.rho_pos z) hm hjump hcoverage hsigned hbank hnarrow hpass |
| refine ⟨⟨k,by omega⟩,?_⟩ |
| intro i hi |
| have he : i.val/B*B=i.val := by |
| have H := Nat.mod_add_div i.val B |
| rw [hi,zero_add,Nat.mul_comm] at H |
| exact H |
| have H := Hk (i.val/B) (by simpa only [he] using i.isLt) |
| rw [he,gridThresholds,dite_eq_left i.isLt] at H |
| exact H |
| have h1 : 1≤P.prob bad+P.prob (fun z => ∃k : Fin (m+1),W k z) := by |
| have he : P.prob (fun z => bad z ∨ ∃k : Fin (m+1),W k z)=1 := by |
| unfold FiniteLaw.prob |
| simp only [hall,ite_true,FiniteLaw.expect_const] |
| rw [← he] |
| exact P.prob_or _ _ |
| have hm := gridThresholds_good_mass hn μ p t ρ G.rho_pos |
| have hw : P.prob (fun z => ∃k : Fin (m+1),W k z)≤(m+1)*(2*(6*p*ρ^20)/ρ+1/(n:ℝ))^s := by |
| refine (P.prob_exists W).trans ?_ |
| calc |
| _ ≤ ∑ _k : Fin (m+1),(2*(6*p*ρ^20)/ρ+1/(n:ℝ))^s := by |
| apply Finset.sum_le_sum |
| intro k _ |
| exact greedy_grid_windows_bound hn base (bankPick pool fallback B x t q) x B s m G.B_pos t ρ b |
| (6*p*ρ^20) G.rho_pos (by positivity) k.val |
| _ = _ := by simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul,Nat.cast_add,Nat.cast_one] |
| change P.prob bad≤_ at hm |
| simp only [p,Nat.cast_mul] at hm hw h1 |
| linarith only [h1,hm,hw,hcount] |
|
|
| end SK.Analytic |
|
|
| end |
| end |
|
|
| end OAI |
|
|
