| import Mathlib |
| import OAI.Analysis.HardSphere.Paths.NearPotential |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped ENNReal BigOperators Topology |
| namespace HardSphere.DyadicSkeleton |
|
|
| lemma refineStep_mem (a b x : Vertex) (hx : x ∈ refineStep a b) : |
| x 0 = b 0 ∧ ∀j, |x j-b j| ≤ |a j-b j| := by |
| simp only [refineStep,List.mem_append,List.mem_singleton,List.mem_map] at hx |
| rcases hx with (rfl|⟨c,hc,rfl⟩)|⟨c,hc,rfl⟩ |
| · refine ⟨rfl,?_⟩ |
| intro j |
| fin_cases j <;> simp |
| · refine ⟨rfl,?_⟩ |
| intro j |
| fin_cases j |
| · simp |
| · exact axisSteps_near_final _ _ _ hc |
| · simp |
| · refine ⟨rfl,?_⟩ |
| intro j |
| fin_cases j |
| · simp |
| · simp |
| · exact axisSteps_near_final _ _ _ hc |
|
|
| def levelList (n : ℕ) (d : Fin 2 → ℤ) (ω : Noise) : ℕ → List Vertex |
| | 0 => [baseVertex n d ω 0] |
| | t+1 => refineStep (baseVertex n d ω t) (baseVertex n d ω (t+1)) |
|
|
| def occurrenceList (n : ℕ) (d : Fin 2 → ℤ) (ω : Noise) : List Vertex := |
| (List.range (n+1)).flatMap (levelList n d ω) |
|
|
| lemma levelList_length (n : ℕ) (hn : 0 < n) (d : Fin 2 → ℤ) |
| (hd : ∀j, |d j| ≤ n) (ω : Noise) (t : ℕ) (ht : t ≤ n) : |
| (levelList n d ω t).length ≤ 5 := by |
| cases t with |
| | zero => simp [levelList] |
| | succ t => exact refineStep_length _ _ (baseVertex_step n hn d hd ω t (by omega)) |
|
|
| lemma levelList_mem (n : ℕ) (hn : 0 < n) (d : Fin 2 → ℤ) |
| (hd : ∀j, |d j| ≤ n) (ω : Noise) (t : ℕ) (ht : t ≤ n) |
| (x : Vertex) (hx : x ∈ levelList n d ω t) : |
| x 0 = (t:ℤ) ∧ ∀j, |x j-baseVertex n d ω t j| ≤ 2 := by |
| cases t with |
| | zero => |
| have he : x = baseVertex n d ω 0 := by simpa only [levelList,List.mem_singleton] using hx |
| subst x |
| simp [baseVertex] |
| | succ t => |
| obtain ⟨h0,hb⟩ := refineStep_mem _ _ x hx |
| refine ⟨h0,fun j ↦ (hb j).trans ?_⟩ |
| rw [abs_sub_comm] |
| exact baseVertex_step n hn d hd ω t (by omega) j |
|
|
| lemma occurrenceList_initial (n : ℕ) (d : Fin 2 → ℤ) (ω : Noise) : |
| (0:Vertex) ∈ occurrenceList n d ω := by |
| apply List.mem_flatMap.mpr |
| refine ⟨0,by simp,?_⟩ |
| simp [levelList,baseVertex_initial] |
|
|
| lemma integer_step_lipschitz (f : ℕ → ℤ) (H : ℕ) (L : ℤ) |
| (hstep : ∀ i<H, |f (i+1)-f i|≤L) {i j : ℕ} (hi : i≤H) (hj : j≤H) : |
| |f i-f j|≤L*|(i:ℤ)-j| := by |
| have hforward : ∀ a b, a≤b → b≤H → |f b-f a|≤L*((b:ℤ)-a) := by |
| intro a b hab hb |
| induction b,hab using Nat.le_induction with |
| | base => simp |
| | @succ b hab ih => |
| have h := hstep b (by omega) |
| have hh := ih (by omega) |
| calc |
| |f (b+1)-f a| ≤ |f (b+1)-f b|+|f b-f a| := abs_sub_le _ _ _ |
| _ ≤ L+L*((b:ℤ)-a) := add_le_add h hh |
| _ = _ := by push_cast; ring |
| rcases le_total i j with h|h |
| · rw [abs_sub_comm (f i),abs_sub_comm (i:ℤ),abs_of_nonneg (by omega : 0≤(j:ℤ)-i)] |
| exact hforward i j h hj |
| · rw [abs_of_nonneg (by omega : 0≤(i:ℤ)-j)] |
| exact hforward j i h hi |
|
|
| lemma baseVertex_lipschitz (n : ℕ) (hn : 0 < n) (d : Fin 2 → ℤ) |
| (hd : ∀j, |d j| ≤ n) (ω : Noise) (s t : ℕ) (hs : s ≤ n) (ht : t ≤ n) (j : Fin 3) : |
| |baseVertex n d ω s j-baseVertex n d ω t j| ≤ 2*|(s:ℤ)-t| := |
| integer_step_lipschitz (fun u ↦ baseVertex n d ω u j) n 2 |
| (fun k hk ↦ baseVertex_step n hn d hd ω k hk j) hs ht |
|
|
| lemma real_sub_floor_le (x y : ℝ) : |x-y| ≤ |(⌊x⌋:ℝ)-(⌊y⌋:ℝ)|+1 := by |
| have h1 := Int.floor_le x |
| have h2 := Int.lt_floor_add_one x |
| have h3 := Int.floor_le y |
| have h4 := Int.lt_floor_add_one y |
| have hl := neg_abs_le ((⌊x⌋:ℝ)-(⌊y⌋:ℝ)) |
| have hu := le_abs_self ((⌊x⌋:ℝ)-(⌊y⌋:ℝ)) |
| apply abs_le.mpr |
| constructor <;> linarith |
|
|
| lemma floor_sub_real_le (x y : ℝ) : |(⌊x⌋:ℝ)-(⌊y⌋:ℝ)| ≤ |x-y|+1 := by |
| have h1 := Int.floor_le x |
| have h2 := Int.lt_floor_add_one x |
| have h3 := Int.floor_le y |
| have h4 := Int.lt_floor_add_one y |
| have hl := neg_abs_le (x-y) |
| have hu := le_abs_self (x-y) |
| apply abs_le.mpr |
| constructor <;> linarith |
|
|
| lemma same_time_position_bound (n t : ℕ) (ht : t ≤ n) (ω ω' : Noise) (j : Fin 2) : |
| |position ω j (min t (n-t))-position ω' j (min t (n-t))| ≤ (n:ℝ)/2 := by |
| have hu : 2*(min t (n-t)) ≤ n := by omega |
| have hu' : 2*((min t (n-t):ℕ):ℝ) ≤ (n:ℝ) := by exact_mod_cast hu |
| calc |
| _ ≤ |position ω j (min t (n-t))|+|position ω' j (min t (n-t))| := abs_sub _ _ |
| _ ≤ ((min t (n-t):ℕ):ℝ)/2+((min t (n-t):ℕ):ℝ)/2 := |
| add_le_add (position_abs_le ω j _) (position_abs_le ω' j _) |
| _ ≤ _ := by linarith |
|
|
| lemma same_time_floor_bound (n t : ℕ) (ht : t ≤ n) (d : Fin 2 → ℤ) |
| (ω ω' : Noise) (j : Fin 3) : |
| |(baseVertex n d ω t j:ℝ)-(baseVertex n d ω' t j:ℝ)| ≤ (n:ℝ)/2+1 := by |
| have hh (i : Fin 2) : |(⌊baseTrans n d ω t i⌋:ℝ)-(⌊baseTrans n d ω' t i⌋:ℝ)| ≤ |
| (n:ℝ)/2+1 := by |
| have h := floor_sub_real_le (baseTrans n d ω t i) (baseTrans n d ω' t i) |
| have he : baseTrans n d ω t i-baseTrans n d ω' t i = |
| position ω i (min t (n-t))-position ω' i (min t (n-t)) := by unfold baseTrans; ring |
| rw [he] at h |
| exact h.trans (add_le_add (same_time_position_bound n t ht ω ω' i) le_rfl) |
| fin_cases j |
| · change |(t:ℝ)-(t:ℝ)| ≤ _ |
| rw [sub_self,abs_zero] |
| positivity |
| · exact hh 0 |
| · exact hh 1 |
|
|
| def periodicProjection (K : ℕ) (x : Vertex) : Fin 3 → AddCircle (K:ℝ) := |
| fun j ↦ ((x j:ℝ) : AddCircle (K:ℝ)) |
|
|
| def periodicDistance (K : ℕ) (x y : Vertex) : ℝ := |
| dist (periodicProjection K x) (periodicProjection K y) |
|
|
| lemma periodicDistance_nonneg (K : ℕ) (x y : Vertex) : 0 ≤ periodicDistance K x y := dist_nonneg |
| lemma periodicDistance_symm (K : ℕ) (x y : Vertex) : |
| periodicDistance K x y = periodicDistance K y x := dist_comm _ _ |
| lemma periodicDistance_triangle (K : ℕ) (x y z : Vertex) : |
| periodicDistance K x z ≤ periodicDistance K x y+periodicDistance K y z := dist_triangle _ _ _ |
|
|
| lemma periodicDistance_le (K : ℕ) (x y : Vertex) (r : ℝ) (hr : 0 ≤ r) |
| (h : ∀j, |(x j:ℝ)-(y j:ℝ)| ≤ r) : periodicDistance K x y ≤ r := by |
| apply (dist_pi_le_iff hr).mpr |
| intro j |
| change dist ((x j:ℝ):AddCircle (K:ℝ)) ((y j:ℝ):AddCircle (K:ℝ)) ≤ r |
| rw [dist_eq_norm,← QuotientAddGroup.mk_sub] |
| exact QuotientAddGroup.norm_mk_le_norm.trans (by simpa only [Real.norm_eq_abs] using h j) |
|
|
| lemma periodicDistance_coord (K : ℕ) (hK : 0 < K) (x y : Vertex) (j : Fin 3) |
| (h : |(x j:ℝ)-(y j:ℝ)| ≤ (K:ℝ)/2) : |
| |(x j:ℝ)-(y j:ℝ)| ≤ periodicDistance K x y := by |
| have hK' : 0 < (K:ℝ) := by exact_mod_cast hK |
| have he : dist ((x j:ℝ):AddCircle (K:ℝ)) ((y j:ℝ):AddCircle (K:ℝ)) = |
| |(x j:ℝ)-(y j:ℝ)| := by |
| rw [dist_eq_norm,← QuotientAddGroup.mk_sub] |
| exact (AddCircle.norm_coe_eq_abs_iff (K:ℝ) (ne_of_gt hK')).mpr |
| (by simpa only [abs_of_pos hK'] using h) |
| rw [← he] |
| exact dist_le_pi_dist (periodicProjection K x) (periodicProjection K y) j |
|
|
| lemma periodicDistance_le_half (K : ℕ) (hK : 0 < K) (x y : Vertex) : |
| periodicDistance K x y ≤ (K:ℝ)/2 := by |
| have hK' : 0 < (K:ℝ) := by exact_mod_cast hK |
| apply (dist_pi_le_iff (by positivity : 0 ≤ (K:ℝ)/2)).mpr |
| intro j |
| rw [dist_eq_norm] |
| simpa only [abs_of_pos hK'] using AddCircle.norm_le_half_period (K:ℝ) (x := |
| periodicProjection K x j-periodicProjection K y j) (ne_of_gt hK') |
|
|
| lemma same_time_deviation_le (K n : ℕ) (hn : 0 < n) (hnK : 8*n ≤ K) |
| (d : Fin 2 → ℤ) (ω ω' : Noise) (t : ℕ) (ht : t ≤ n) : |
| twoCopyDistance (min t (n-t)) (ω,ω') ≤ |
| periodicDistance K (baseVertex n d ω t) (baseVertex n d ω' t)+1 := by |
| have hK : 0 < K := by omega |
| have htrans (i : Fin 2) (j : Fin 3) |
| (he : baseVertex n d ω t j = ⌊baseTrans n d ω t i⌋) |
| (he' : baseVertex n d ω' t j = ⌊baseTrans n d ω' t i⌋) : |
| |position ω i (min t (n-t))-position ω' i (min t (n-t))| ≤ |
| periodicDistance K (baseVertex n d ω t) (baseVertex n d ω' t)+1 := by |
| have hp := periodicDistance_coord K hK (baseVertex n d ω t) (baseVertex n d ω' t) j |
| ((same_time_floor_bound n t ht d ω ω' j).trans (by |
| have hnr : (1:ℝ) ≤ (n:ℝ) := by exact_mod_cast hn |
| have hkr : 8*(n:ℝ) ≤ (K:ℝ) := by exact_mod_cast hnK |
| linarith)) |
| rw [he,he'] at hp |
| have hh := real_sub_floor_le (baseTrans n d ω t i) (baseTrans n d ω' t i) |
| have heq : baseTrans n d ω t i-baseTrans n d ω' t i = |
| position ω i (min t (n-t))-position ω' i (min t (n-t)) := by unfold baseTrans; ring |
| rw [heq] at hh |
| exact hh.trans (add_le_add hp le_rfl) |
| exact max_le (htrans 0 1 rfl rfl) (htrans 1 2 rfl rfl) |
|
|
| lemma occurrence_deviation_le (K n : ℕ) (hn : 0 < n) (hnK : 8*n ≤ K) |
| (d : Fin 2 → ℤ) (hd : ∀j, |d j| ≤ n) (ω ω' : Noise) |
| (s t : ℕ) (hs : s ≤ n) (ht : t ≤ n) (x y : Vertex) |
| (hx : x ∈ levelList n d ω s) (hy : y ∈ levelList n d ω' t) : |
| twoCopyDistance (min s (n-s)) (ω,ω') ≤ 3*periodicDistance K x y+5 := by |
| obtain ⟨hx0,hxb⟩ := levelList_mem n hn d hd ω s hs x hx |
| obtain ⟨hy0,hyb⟩ := levelList_mem n hn d hd ω' t ht y hy |
| have hK : 0 < K := by omega |
| have hst : |(s:ℝ)-(t:ℝ)| ≤ periodicDistance K x y := by |
| have h := periodicDistance_coord K hK x y 0 (by |
| rw [hx0,hy0]; push_cast |
| apply (abs_le.mpr ⟨by |
| have hn' : 8*(n:ℝ) ≤ (K:ℝ) := by exact_mod_cast hnK |
| have hs' : (s:ℝ) ≤ n := by exact_mod_cast hs |
| have ht' : (t:ℝ) ≤ n := by exact_mod_cast ht |
| have hsz : (0:ℝ) ≤ s := by positivity |
| linarith,by |
| have hn' : 8*(n:ℝ) ≤ (K:ℝ) := by exact_mod_cast hnK |
| have hs' : (s:ℝ) ≤ n := by exact_mod_cast hs |
| have ht' : (t:ℝ) ≤ n := by exact_mod_cast ht |
| have htz : (0:ℝ) ≤ t := by positivity |
| linarith⟩)) |
| simpa only [hx0,hy0,Int.cast_natCast] using h |
| have hxb' : periodicDistance K (baseVertex n d ω s) x ≤ 2 := by |
| apply periodicDistance_le _ _ _ 2 (by norm_num) |
| intro j |
| rw [abs_sub_comm] |
| exact_mod_cast hxb j |
| have hyb' : periodicDistance K y (baseVertex n d ω' t) ≤ 2 := by |
| apply periodicDistance_le _ _ _ 2 (by norm_num) |
| intro j |
| exact_mod_cast hyb j |
| have hbb : periodicDistance K (baseVertex n d ω' t) (baseVertex n d ω' s) ≤ |
| 2*periodicDistance K x y := by |
| apply periodicDistance_le _ _ _ _ (mul_nonneg (by norm_num) (periodicDistance_nonneg _ _ _)) |
| intro j |
| have h : |(baseVertex n d ω' t j:ℝ)-(baseVertex n d ω' s j:ℝ)| ≤ |
| 2*|(t:ℝ)-(s:ℝ)| := by |
| exact_mod_cast baseVertex_lipschitz n hn d hd ω' t s ht hs j |
| rw [abs_sub_comm (t:ℝ)] at h |
| linarith |
| have htri1 := periodicDistance_triangle K (baseVertex n d ω s) x y |
| have htri2 := periodicDistance_triangle K (baseVertex n d ω s) y (baseVertex n d ω' t) |
| have htri3 := periodicDistance_triangle K (baseVertex n d ω s) |
| (baseVertex n d ω' t) (baseVertex n d ω' s) |
| have hdev := same_time_deviation_le K n hn hnK d ω ω' s hs |
| linarith |
|
|
| def distanceToList (K : ℕ) (x : Vertex) (l : List Vertex) : ℝ := |
| l.foldr (fun y r ↦ min (periodicDistance K x y) r) ((K:ℝ)/2) |
|
|
| lemma distanceToList_nonneg (K : ℕ) (x : Vertex) (l : List Vertex) : |
| 0 ≤ distanceToList K x l := by |
| induction l with |
| | nil => simp only [distanceToList,List.foldr_nil]; positivity |
| | cons y l ih => exact le_min (periodicDistance_nonneg _ _ _) ih |
|
|
| lemma distanceToList_le (K : ℕ) (x y : Vertex) (l : List Vertex) (hy : y ∈ l) : |
| distanceToList K x l ≤ periodicDistance K x y := by |
| induction l with |
| | nil => simp at hy |
| | cons z l ih => |
| rcases List.mem_cons.mp hy with rfl|hy |
| · exact min_le_left _ _ |
| · exact (min_le_right _ _).trans (ih hy) |
|
|
| lemma distanceToList_attained (K : ℕ) (hK : 0 < K) (x : Vertex) (l : List Vertex) |
| (hne : l ≠ []) : ∃ y ∈ l, distanceToList K x l = periodicDistance K x y := by |
| induction l with |
| | nil => exact False.elim (hne rfl) |
| | cons z l ih => |
| by_cases hl : l = [] |
| · subst l |
| refine ⟨z,by simp,?_⟩ |
| exact min_eq_left (periodicDistance_le_half K hK x z) |
| · obtain ⟨y,hy,he⟩ := ih hl |
| change ∃ y ∈ z::l, min (periodicDistance K x z) (distanceToList K x l) = _ |
| rcases le_total (periodicDistance K x z) (distanceToList K x l) with h|h |
| · exact ⟨z,by simp,min_eq_left h⟩ |
| · exact ⟨y,by simp [hy],(min_eq_right h).trans he⟩ |
|
|
| lemma occurrenceList_ne_nil (n : ℕ) (d : Fin 2 → ℤ) (ω : Noise) : |
| occurrenceList n d ω ≠ [] := List.ne_nil_of_mem (occurrenceList_initial n d ω) |
|
|
| lemma distanceToList_deviation_le (K n : ℕ) (hn : 0 < n) (hnK : 8*n ≤ K) |
| (d : Fin 2 → ℤ) (hd : ∀j, |d j| ≤ n) (ω ω' : Noise) |
| (s : ℕ) (hs : s ≤ n) (x : Vertex) (hx : x ∈ levelList n d ω s) : |
| twoCopyDistance (min s (n-s)) (ω,ω') ≤ |
| 3*distanceToList K x (occurrenceList n d ω')+5 := by |
| obtain ⟨y,hy,he⟩ := distanceToList_attained K (by omega) x _ (occurrenceList_ne_nil n d ω') |
| obtain ⟨t,ht,hy⟩ := List.mem_flatMap.mp hy |
| rw [List.mem_range] at ht |
| rw [he] |
| exact occurrence_deviation_le K n hn hnK d hd ω ω' s t hs (by omega) x y hx hy |
|
|
| def foldIndex (n : ℕ) (j : Fin (n+1)) : Fin (n/2+1) × Bool := |
| if hj : j.val ≤ n/2 then (⟨j.val, by omega⟩, false) |
| else (⟨n-j.val, by omega⟩, true) |
|
|
| lemma foldIndex_value (n : ℕ) (j : Fin (n+1)) : |
| (foldIndex n j).1.val = min j.val (n-j.val) := by |
| unfold foldIndex |
| split_ifs with h <;> simp only |
| · omega |
| · omega |
|
|
| lemma foldIndex_injective (n : ℕ) : Function.Injective (foldIndex n) := by |
| intro i j h |
| have h₁ := congrArg (fun x : Fin (n/2+1) × Bool ↦ x.1.val) h |
| have h₂ := congrArg Prod.snd h |
| unfold foldIndex at h₁ h₂ |
| split_ifs at h₁ h₂ <;> simp_all only |
| all_goals apply Fin.ext; omega |
|
|
| lemma folded_sum_le (n : ℕ) (f : ℕ → ℝ) (hf : ∀ j, 0 ≤ f j) : |
| (∑ j ∈ Finset.range (n+1), f (min j (n-j))) ≤ |
| 2 * ∑ j ∈ Finset.range (n/2+1), f j := by |
| let g : Fin (n/2+1) × Bool → ℝ := fun x ↦ f x.1.val |
| have hs : (∑ x ∈ Finset.univ.image (foldIndex n), g x) ≤ ∑ x, g x := by |
| exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _) (fun x _ _ ↦ hf _) |
| rw [Finset.sum_image (fun i _ j _ hij ↦ foldIndex_injective n hij)] at hs |
| have hleft : (∑ i : Fin (n+1), g (foldIndex n i)) = |
| ∑ j ∈ Finset.range (n+1), f (min j (n-j)) := by |
| simp only [g, foldIndex_value] |
| exact Fin.sum_univ_eq_sum_range (fun j ↦ f (min j (n-j))) (n+1) |
| have hright : (∑ x : Fin (n/2+1) × Bool, g x) = |
| 2 * ∑ j ∈ Finset.range (n/2+1), f j := by |
| simp only [Fintype.sum_prod_type, Fintype.sum_bool, g, ← two_mul, ← Finset.mul_sum, |
| Fin.sum_univ_eq_sum_range] |
| simpa only [hleft, hright] using hs |
|
|
| lemma nearPotential_eq_if (u : ℕ) (R : ℝ) (z : Noise × Noise) : |
| nearPotential u (fun j ↦ position z.2 j u) R z.1 = |
| if twoCopyDistance u z ≤ R then 1 else 0 := by |
| unfold nearPotential nearTest coordinateTest twoCopyDistance transverseDistance |
| by_cases h0 : |position z.1 0 u-position z.2 0 u| ≤ R <;> |
| by_cases h1 : |position z.1 1 u-position z.2 1 u| ≤ R <;> |
| simp [h0,h1] |
|
|
| lemma twoCopyDistance_swap (u : ℕ) (z : Noise × Noise) : |
| twoCopyDistance u z.swap = twoCopyDistance u z := by |
| simp only [twoCopyDistance,transverseDistance,Prod.swap] |
| rw [abs_sub_comm (position z.2 0 u),abs_sub_comm (position z.2 1 u)] |
|
|
| lemma nearPotential_swap (u : ℕ) (R : ℝ) (ω ω' : Noise) : |
| nearPotential u (fun j ↦ position ω j u) R ω' = |
| nearPotential u (fun j ↦ position ω' j u) R ω := by |
| rw [nearPotential_eq_if (z := (ω',ω)),nearPotential_eq_if (z := (ω,ω'))] |
| rw [show twoCopyDistance u (ω',ω) = twoCopyDistance u (ω,ω') from |
| twoCopyDistance_swap u (ω,ω')] |
|
|
| def oneSideHit (K : ℕ) (R : ℝ) (l l' : List Vertex) : ℝ := |
| (l.map (fun x ↦ if distanceToList K x l' ≤ R then 1 else 0)).sum |
|
|
| def occurrenceHit (K : ℕ) (R : ℝ) (l l' : List Vertex) : ℝ := |
| oneSideHit K R l l'+oneSideHit K R l' l |
|
|
| def occurrenceSoft (K : ℕ) (B : ℝ) (l l' : List Vertex) : ℝ := |
| (l.map (fun x ↦ Real.exp (-distanceToList K x l'/B))).sum |
|
|
| lemma oneSideHit_nonneg (K : ℕ) (R : ℝ) (l l' : List Vertex) : |
| 0 ≤ oneSideHit K R l l' := by |
| apply List.sum_nonneg |
| intro a ha |
| obtain ⟨x,hx,rfl⟩ := List.mem_map.mp ha |
| split_ifs <;> norm_num |
|
|
| lemma occurrenceHit_nonneg (K : ℕ) (R : ℝ) (l l' : List Vertex) : |
| 0 ≤ occurrenceHit K R l l' := add_nonneg |
| (oneSideHit_nonneg _ _ _ _) (oneSideHit_nonneg _ _ _ _) |
|
|
| lemma level_sum_le (n : ℕ) (hn : 0 < n) (d : Fin 2 → ℤ) |
| (hd : ∀j, |d j| ≤ n) (ω : Noise) (f : Vertex → ℝ) (g : ℕ → ℝ) |
| (hg : ∀t, 0 ≤ g t) |
| (hfg : ∀t ≤ n, ∀x ∈ levelList n d ω t, f x ≤ g t) : |
| ((occurrenceList n d ω).map f).sum ≤ |
| 5*∑ t ∈ Finset.range (n+1), g t := by |
| have hlevel (t : ℕ) (ht : t ≤ n) : |
| ((levelList n d ω t).map f).sum ≤ 5*g t := by |
| calc |
| _ ≤ ((levelList n d ω t).map (fun _ ↦ g t)).sum := by |
| apply List.sum_le_sum |
| intro x hx |
| exact hfg t ht x hx |
| _ = ((levelList n d ω t).length:ℝ)*g t := by simp [nsmul_eq_mul] |
| _ ≤ _ := mul_le_mul_of_nonneg_right (by |
| exact_mod_cast levelList_length n hn d hd ω t ht) (hg t) |
| unfold occurrenceList |
| rw [List.flatMap_def,List.map_flatten,List.sum_flatten] |
| simp only [List.map_map] |
| calc |
| _ ≤ ((List.range (n+1)).map (fun t ↦ 5*g t)).sum := by |
| apply List.sum_le_sum |
| intro t ht |
| exact hlevel t (Nat.le_of_lt_succ (List.mem_range.mp ht)) |
| _ = _ := by |
| rw [List.sum_map_mul_left,← List.sum_toFinset g List.nodup_range,List.toFinset_range] |
|
|
| lemma oneSideHit_le (K n : ℕ) (hn : 0 < n) (hnK : 8*n ≤ K) |
| (d : Fin 2 → ℤ) (hd : ∀j, |d j| ≤ n) (ω ω' : Noise) (R : ℝ) : |
| oneSideHit K R (occurrenceList n d ω) (occurrenceList n d ω') ≤ |
| 10*∑ u ∈ Finset.range (n/2+1), |
| nearPotential u (fun j ↦ position ω' j u) (3*R+5) ω := by |
| have h := level_sum_le n hn d hd ω |
| (fun x ↦ if distanceToList K x (occurrenceList n d ω') ≤ R then 1 else 0) |
| (fun t ↦ nearPotential (min t (n-t)) |
| (fun j ↦ position ω' j (min t (n-t))) (3*R+5) ω) |
| (fun _ ↦ nearPotential_nonneg _ _ _ _) (by |
| intro t ht x hx |
| split_ifs with h |
| · rw [nearPotential_eq_if (z := (ω,ω'))] |
| rw [ite_eq_left (by linarith [distanceToList_deviation_le K n hn hnK d hd ω ω' t ht x hx])] |
| · exact nearPotential_nonneg _ _ _ _) |
| have hf := folded_sum_le n |
| (fun u ↦ nearPotential u (fun j ↦ position ω' j u) (3*R+5) ω) |
| (fun _ ↦ nearPotential_nonneg _ _ _ _) |
| change oneSideHit K R _ _ ≤ _ at h |
| linarith |
|
|
| end HardSphere.DyadicSkeleton |
| end |
| end |
|
|
| end OAI |
|
|
