| import Mathlib |
| import OAI.Analysis.HardSphere.Paths.TimeGaps |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped ENNReal BigOperators Topology |
| namespace HardSphere.DyadicSkeleton |
|
|
| lemma orderedEncounterConstant_one_le : 1 ≤ orderedEncounterConstant := by |
| simpa only [orderedEncounterConstant,ENNReal.toReal_one] using |
| ENNReal.toReal_mono gapKernel_sum_ne_top gapKernel_sum_one_le |
|
|
| def nearPotential (n : ℕ) (y : Fin 2 → ℝ) (R : ℝ) (ω : Noise) : ℝ := |
| (nearTest n y R ω).toReal |
| lemma nearPotential_nonneg (n : ℕ) (y : Fin 2 → ℝ) (R : ℝ) (ω : Noise) : |
| 0 ≤ nearPotential n y R ω := ENNReal.toReal_nonneg |
| lemma nearPotential_le_one (n : ℕ) (y : Fin 2 → ℝ) (R : ℝ) (ω : Noise) : |
| nearPotential n y R ω ≤ 1 := by |
| simpa only [nearPotential,ENNReal.toReal_one] using |
| ENNReal.toReal_mono (by norm_num : (1:ℝ≥0∞) ≠ ∞) (nearTest_le_one n y R ω) |
| lemma nearPotential_cast (n : ℕ) (y : Fin 2 → ℝ) (R : ℝ) (ω : Noise) : |
| ENNReal.ofReal (nearPotential n y R ω) = nearTest n y R ω := |
| ENNReal.ofReal_toReal (ne_top_of_le_ne_top (by norm_num) (nearTest_le_one n y R ω)) |
| @[fun_prop] lemma measurable_nearPotential (n : ℕ) (y : Fin 2 → ℝ) (R : ℝ) : |
| Measurable (nearPotential n y R) := (measurable_nearTest n y R).ennreal_toReal |
|
|
| def singleRadiusWeights (R : ℕ) (a : ℝ≥0∞) (l : ℕ) : ℝ≥0∞ := if l=R then a else 0 |
| lemma singleRadiusWeights_envelope (R : ℕ) (a : ℝ≥0∞) (n : ℕ) |
| (y : Fin 2 → ℝ) (ω : Noise) : |
| radiusEnvelope (singleRadiusWeights R a) n y ω = a * nearTest n y (R:ℝ) ω := by |
| simp [radiusEnvelope,singleRadiusWeights,ite_mul] |
| lemma singleRadiusWeights_activity (R : ℕ) (a : ℝ≥0∞) : |
| radiusActivity (singleRadiusWeights R a) = |
| ENNReal.ofReal orderedEncounterConstant * (a * radiusFactor (R:ℝ)) := by |
| simp [radiusActivity,singleRadiusWeights,ite_mul] |
|
|
| def hitConstant : ℝ := (4 * Real.exp 2 * orderedEncounterConstant)⁻¹ |
| lemma hitConstant_pos : 0 < hitConstant := by |
| unfold hitConstant |
| positivity [orderedEncounterConstant_pos] |
| lemma hitConstant_le_one : hitConstant ≤ 1 := by |
| have he : 1 ≤ Real.exp 2 := Real.one_le_exp (by norm_num) |
| have hc := orderedEncounterConstant_one_le |
| have hd : 1 ≤ 4 * Real.exp 2 * orderedEncounterConstant := by nlinarith |
| exact (inv_le_one₀ (by positivity)).mpr hd |
|
|
| lemma same_time_hit_moment (T R : ℕ) (y : ℕ → Fin 2 → ℝ) : |
| (∫⁻ ω, ENNReal.ofReal (Real.exp ((hitConstant/(1+(R:ℝ))^2) * |
| ∑ u ∈ Finset.range (T+1), nearPotential u (y u) (R:ℝ) ω)) ∂law) ≤ 2 := by |
| let a := hitConstant/(2*(1+(R:ℝ))^2) |
| have hp : 0 < (1+(R:ℝ))^2 := by positivity |
| have ha : 0 ≤ a := by dsimp [a]; exact div_nonneg hitConstant_pos.le (by positivity) |
| have ha1 : a ≤ 1 := by |
| dsimp [a] |
| apply (div_le_one (by positivity)).mpr |
| have hr := Nat.cast_nonneg (α:=ℝ) R |
| nlinarith [hitConstant_le_one] |
| have hsmall : ENNReal.ofReal (2*Real.exp 2) * |
| radiusActivity (singleRadiusWeights R (ENNReal.ofReal a)) ≤ (1/2:ℝ≥0∞) := by |
| rw [singleRadiusWeights_activity,radiusFactor, |
| ← ENNReal.ofReal_mul ha,← ENNReal.ofReal_mul orderedEncounterConstant_pos.le, |
| ← ENNReal.ofReal_mul (by positivity : 0 ≤ 2*Real.exp 2)] |
| have heq : 2*Real.exp 2*(orderedEncounterConstant*(a*(1+(R:ℝ))^2)) = 1/4 := by |
| dsimp [a,hitConstant] |
| field_simp [ne_of_gt orderedEncounterConstant_pos,ne_of_gt (Real.exp_pos 2)] |
| rw [heq] |
| norm_num [ENNReal.ofReal_div_of_pos] |
| have h := radius_exponential_bound T (singleRadiusWeights R (ENNReal.ofReal a)) y |
| (fun n ω ↦ a*nearPotential n (y n) (R:ℝ) ω) |
| (fun n ω ↦ mul_nonneg ha (nearPotential_nonneg n (y n) (R:ℝ) ω)) |
| (fun n ω ↦ (mul_le_mul_of_nonneg_left (nearPotential_le_one n (y n) (R:ℝ) ω) ha).trans |
| (by simpa using ha1)) |
| (by intro n ω; rw [ENNReal.ofReal_mul ha,nearPotential_cast,singleRadiusWeights_envelope]) hsmall |
| convert h using 1 |
| apply lintegral_congr |
| intro ω |
| congr 2 |
| rw [← Finset.mul_sum] |
| dsimp [a] |
| field_simp |
|
|
| def transverseDistance (n : ℕ) (y : Fin 2 → ℝ) (ω : Noise) : ℝ := |
| max |position ω 0 n-y 0| |position ω 1 n-y 1| |
| lemma transverseDistance_nonneg (n : ℕ) (y : Fin 2 → ℝ) (ω : Noise) : |
| 0 ≤ transverseDistance n y ω := (abs_nonneg _).trans (le_max_left _ _) |
| @[fun_prop] lemma measurable_transverseDistance (n : ℕ) (y : Fin 2 → ℝ) : |
| Measurable (transverseDistance n y) := by unfold transverseDistance; fun_prop |
| lemma nearTest_eq_one (n : ℕ) (y : Fin 2 → ℝ) (R : ℝ) (ω : Noise) |
| (h : transverseDistance n y ω ≤ R) : nearTest n y R ω = 1 := by |
| have h' := max_le_iff.mp h |
| simp [nearTest,coordinateTest,h'.1,h'.2] |
|
|
| def softPotential (B : ℝ) (n : ℕ) (y : Fin 2 → ℝ) (ω : Noise) : ℝ := |
| Real.exp (-transverseDistance n y ω/B) |
| lemma softPotential_nonneg (B : ℝ) (n : ℕ) (y : Fin 2 → ℝ) (ω : Noise) : |
| 0 ≤ softPotential B n y ω := (Real.exp_pos _).le |
| lemma softPotential_le_one (B : ℝ) (hB : 0 < B) (n : ℕ) (y : Fin 2 → ℝ) (ω : Noise) : |
| softPotential B n y ω ≤ 1 := |
| Real.exp_le_one_iff.mpr (div_nonpos_of_nonpos_of_nonneg (by |
| linarith [transverseDistance_nonneg n y ω]) hB.le) |
| @[fun_prop] lemma measurable_softPotential (B : ℝ) (n : ℕ) (y : Fin 2 → ℝ) : |
| Measurable (softPotential B n y) := by unfold softPotential; fun_prop |
|
|
| def softWeights (B : ℝ) (l : ℕ) : ℝ≥0∞ := ENNReal.ofReal (Real.exp ((1-(l:ℝ))/B)) |
| lemma softPotential_envelope (B : ℝ) (hB : 0 < B) (n : ℕ) (y : Fin 2 → ℝ) (ω : Noise) : |
| ENNReal.ofReal (softPotential B n y ω) ≤ radiusEnvelope (softWeights B) n y ω := by |
| let l := ⌈transverseDistance n y ω⌉₊ |
| have hl : transverseDistance n y ω ≤ (l:ℝ) := Nat.le_ceil _ |
| have hl' : (l:ℝ) < transverseDistance n y ω+1 := |
| Nat.ceil_lt_add_one (transverseDistance_nonneg n y ω) |
| refine le_trans ?_ (ENNReal.le_tsum (f := fun k : ℕ ↦ |
| softWeights B k * nearTest n y (k:ℝ) ω) l) |
| rw [nearTest_eq_one n y (l:ℝ) ω hl,mul_one] |
| change ENNReal.ofReal (Real.exp (-transverseDistance n y ω/B)) ≤ |
| ENNReal.ofReal (Real.exp ((1-(l:ℝ))/B)) |
| apply ENNReal.ofReal_le_ofReal |
| apply Real.exp_le_exp.mpr |
| exact div_le_div_of_nonneg_right (by linarith) hB.le |
|
|
| lemma soft_activity_ne_top (B : ℝ) (hB : 0 < B) : radiusActivity (softWeights B) ≠ ∞ := by |
| let q := Real.exp (-1/B) |
| have hq : ‖q‖ < 1 := by |
| rw [Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)] |
| apply Real.exp_lt_one_iff.mpr |
| exact div_neg_of_neg_of_pos (by norm_num) hB |
| have hs0 : Summable (fun l : ℕ ↦ q^l) := summable_geometric_of_norm_lt_one hq |
| have hs1 := summable_pow_mul_geometric_of_norm_lt_one 1 hq |
| have hs2 := summable_pow_mul_geometric_of_norm_lt_one 2 hq |
| have hs : Summable (fun l : ℕ ↦ Real.exp ((1-(l:ℝ))/B)*(1+(l:ℝ))^2) := by |
| have h := ((hs2.add (hs1.mul_left 2)).add hs0).mul_left (Real.exp (1/B)) |
| apply h.congr |
| intro l |
| have he : Real.exp ((1-(l:ℝ))/B) = Real.exp (1/B) * q^l := by |
| rw [show (1-(l:ℝ))/B = 1/B + (l:ℝ)*(-1/B) by ring,Real.exp_add,Real.exp_nat_mul] |
| rw [he] |
| simp only [pow_one] |
| ring |
| have he : (∑' l : ℕ, softWeights B l * radiusFactor (l:ℝ)) = |
| ENNReal.ofReal (∑' l : ℕ, Real.exp ((1-(l:ℝ))/B)*(1+(l:ℝ))^2) := by |
| simp only [softWeights,radiusFactor,← ENNReal.ofReal_mul (Real.exp_pos _).le] |
| exact (ENNReal.ofReal_tsum_of_nonneg (fun l ↦ by positivity) hs).symm |
| unfold radiusActivity |
| rw [he] |
| finiteness |
|
|
| lemma same_time_soft_moment (B : ℝ) (hB : 0 < B) : |
| ∃ ξ : ℝ, 0 < ξ ∧ ∀ (T : ℕ) (y : ℕ → Fin 2 → ℝ), |
| (∫⁻ ω, ENNReal.ofReal (Real.exp (ξ * |
| ∑ u ∈ Finset.range (T+1), softPotential B u (y u) ω)) ∂law) ≤ 2 := by |
| let A := (radiusActivity (softWeights B)).toReal |
| let δ := (4*Real.exp 2*(1+A))⁻¹ |
| have hA : 0 ≤ A := ENNReal.toReal_nonneg |
| have hAc : ENNReal.ofReal A = radiusActivity (softWeights B) := |
| ENNReal.ofReal_toReal (soft_activity_ne_top B hB) |
| have hd : 0 < δ := by dsimp [δ]; positivity |
| have hd1 : δ ≤ 1 := by |
| apply (inv_le_one₀ (by positivity)).mpr |
| have he : 1 ≤ Real.exp 2 := Real.one_le_exp (by norm_num) |
| nlinarith |
| refine ⟨2*δ,by positivity,?_⟩ |
| intro T y |
| let a := fun l ↦ ENNReal.ofReal δ * softWeights B l |
| have hsmall : ENNReal.ofReal (2*Real.exp 2) * radiusActivity a ≤ (1/2:ℝ≥0∞) := by |
| rw [show radiusActivity a = ENNReal.ofReal δ * radiusActivity (softWeights B) from |
| radiusActivity_smul _ _,← hAc,← ENNReal.ofReal_mul hd.le, |
| ← ENNReal.ofReal_mul (by positivity : 0 ≤ 2*Real.exp 2)] |
| calc |
| _ ≤ ENNReal.ofReal (1/2:ℝ) := by |
| apply ENNReal.ofReal_le_ofReal |
| dsimp [δ] |
| have he := Real.exp_pos 2 |
| field_simp |
| nlinarith |
| _ = _ := by norm_num [ENNReal.ofReal_div_of_pos] |
| have h := radius_exponential_bound T a y |
| (fun n ω ↦ δ * softPotential B n (y n) ω) |
| (fun n ω ↦ mul_nonneg hd.le (softPotential_nonneg B n (y n) ω)) |
| (fun n ω ↦ (mul_le_mul_of_nonneg_left (softPotential_le_one B hB n (y n) ω) hd.le).trans |
| (by simpa using hd1)) |
| (by |
| intro n ω |
| rw [ENNReal.ofReal_mul hd.le] |
| exact (mul_le_mul_right (softPotential_envelope B hB n (y n) ω) (ENNReal.ofReal δ)).trans_eq |
| (radiusEnvelope_smul _ _ n (y n) ω).symm) hsmall |
| convert h using 1 |
| apply lintegral_congr |
| intro ω |
| congr 2 |
| rw [← Finset.mul_sum] |
| ring |
|
|
| def twoCopyDistance (n : ℕ) (z : Noise × Noise) : ℝ := |
| transverseDistance n (fun j ↦ position z.2 j n) z.1 |
|
|
| @[fun_prop] lemma measurable_twoCopyDistance (n : ℕ) : |
| Measurable (twoCopyDistance n) := by |
| unfold twoCopyDistance transverseDistance |
| exact (((measurable_position 0 n).comp measurable_fst).sub |
| ((measurable_position 0 n).comp measurable_snd)).abs.max |
| (((measurable_position 1 n).comp measurable_fst).sub |
| ((measurable_position 1 n).comp measurable_snd)).abs |
|
|
| @[fun_prop] lemma measurable_twoCopyNear (n : ℕ) (R : ℝ) : |
| Measurable (fun z : Noise × Noise ↦ |
| nearPotential n (fun j ↦ position z.2 j n) R z.1) := by |
| unfold nearPotential nearTest |
| apply Measurable.ennreal_toReal |
| apply Measurable.mul |
| all_goals |
| apply measurable_const.indicator |
| apply measurableSet_le _ measurable_const |
| apply Measurable.abs |
| exact ((measurable_position _ n).comp measurable_fst).sub |
| ((measurable_position _ n).comp measurable_snd) |
|
|
| lemma two_copy_hit_moment (T R : ℕ) : |
| (∫⁻ z, ENNReal.ofReal (Real.exp ((hitConstant/(1+(R:ℝ))^2) * |
| ∑ u ∈ Finset.range (T+1), nearPotential u |
| (fun j ↦ position z.2 j u) (R:ℝ) z.1)) ∂law.prod law) ≤ 2 := by |
| rw [lintegral_prod_symm _ (by |
| apply Measurable.aemeasurable |
| apply Measurable.ennreal_ofReal |
| apply Measurable.exp |
| apply Measurable.const_mul |
| exact Finset.measurable_sum _ (fun u _ ↦ measurable_twoCopyNear u (R:ℝ)))] |
| calc |
| _ ≤ ∫⁻ _ : Noise, (2:ℝ≥0∞) ∂law := lintegral_mono (fun ω ↦ |
| same_time_hit_moment T R (fun u j ↦ position ω j u)) |
| _ = 2 := by simp |
|
|
| lemma two_copy_soft_moment (B : ℝ) (hB : 0 < B) : |
| ∃ ξ : ℝ, 0 < ξ ∧ ∀ T : ℕ, |
| (∫⁻ z, ENNReal.ofReal (Real.exp (ξ * |
| ∑ u ∈ Finset.range (T+1), Real.exp (-twoCopyDistance u z / B))) |
| ∂law.prod law) ≤ 2 := by |
| obtain ⟨ξ,hξ,h⟩ := same_time_soft_moment B hB |
| refine ⟨ξ,hξ,fun T ↦ ?_⟩ |
| rw [lintegral_prod_symm _ (by fun_prop)] |
| calc |
| _ ≤ ∫⁻ _ : Noise, (2:ℝ≥0∞) ∂law := lintegral_mono (fun ω ↦ |
| h T (fun u j ↦ position ω j u)) |
| _ = 2 := by simp |
|
|
| lemma position_lipschitz (ω : Noise) (j : Fin 2) (s t : ℕ) : |
| |position ω j s-position ω j t| ≤ |(s:ℝ)-t|/2 := by |
| have hinc (a k : ℕ) : |position ω j (a+k)-position ω j a| ≤ (k:ℝ)/2 := by |
| induction k with |
| | zero => simp |
| | succ k ih => |
| rw [Nat.add_succ, position_succ] |
| calc |
| _ = |(position ω j (a+k)-position ω j a)+velocity ω j (a+k)| := by congr 1; ring |
| _ ≤ _ := abs_add_le _ _ |
| _ ≤ (k:ℝ)/2+1/2 := add_le_add ih (velocity_abs_le ω j (a+k)) |
| _ = _ := by push_cast; ring |
| rcases le_total t s with h | h |
| · have hs : 0 ≤ (s:ℝ)-t := sub_nonneg.mpr (by exact_mod_cast h) |
| rw [abs_of_nonneg hs] |
| simpa only [Nat.add_sub_of_le h,Nat.cast_sub h] using hinc t (s-t) |
| · have hs : 0 ≤ (t:ℝ)-s := sub_nonneg.mpr (by exact_mod_cast h) |
| rw [abs_sub_comm (s:ℝ),abs_of_nonneg hs,abs_sub_comm (position ω j s)] |
| simpa only [Nat.add_sub_of_le h,Nat.cast_sub h] using hinc s (t-s) |
|
|
| lemma position_abs_le (ω : Noise) (j : Fin 2) (t : ℕ) : |
| |position ω j t| ≤ (t:ℝ)/2 := by |
| simpa [position,abs_of_nonneg (Nat.cast_nonneg (α:=ℝ) t)] using position_lipschitz ω j t 0 |
|
|
| lemma fold_time_lipschitz (n s t : ℕ) (hs : s ≤ n) (ht : t ≤ n) : |
| |((min s (n-s):ℕ):ℝ)-((min t (n-t):ℕ):ℝ)| ≤ |(s:ℝ)-t| := by |
| have h := abs_min_sub_min_le_max (s:ℝ) ((n:ℝ)-s) (t:ℝ) ((n:ℝ)-t) |
| have he : |((n:ℝ)-s)-((n:ℝ)-t)| = |(s:ℝ)-t| := by |
| rw [sub_sub_sub_cancel_left,abs_sub_comm] |
| simpa only [Nat.cast_min,Nat.cast_sub hs,Nat.cast_sub ht,he,max_self] using h |
|
|
| abbrev Vertex := Fin 3 → ℤ |
|
|
| def baseTrans (n : ℕ) (d : Fin 2 → ℤ) (ω : Noise) (t : ℕ) (j : Fin 2) : ℝ := |
| (t:ℝ)*(d j:ℝ)/(n:ℝ)+position ω j (min t (n-t)) |
|
|
| def baseVertex (n : ℕ) (d : Fin 2 → ℤ) (ω : Noise) (t : ℕ) : Vertex := |
| ![(t:ℤ),⌊baseTrans n d ω t 0⌋,⌊baseTrans n d ω t 1⌋] |
|
|
| @[fun_prop] lemma measurable_baseTrans (n : ℕ) (d : Fin 2 → ℤ) (t : ℕ) (j : Fin 2) : |
| Measurable (fun ω ↦ baseTrans n d ω t j) := by unfold baseTrans; fun_prop |
|
|
| @[fun_prop] lemma measurable_baseVertex (n : ℕ) (d : Fin 2 → ℤ) (t : ℕ) : |
| Measurable (fun ω ↦ baseVertex n d ω t) := by |
| apply Measurable.of_eval |
| intro j |
| fin_cases j |
| · exact measurable_const |
| · exact Int.measurable_floor.comp (measurable_baseTrans n d t 0) |
| · exact Int.measurable_floor.comp (measurable_baseTrans n d t 1) |
|
|
| lemma drift_rate_le (n : ℕ) (hn : 0 < n) (d : ℤ) (hd : |d| ≤ n) : |
| |(d:ℝ)/(n:ℝ)| ≤ 1 := by |
| have hn' : 0 < (n:ℝ) := by exact_mod_cast hn |
| rw [abs_div,abs_of_pos hn',div_le_one hn'] |
| exact_mod_cast hd |
|
|
| lemma baseTrans_lipschitz (n : ℕ) (hn : 0 < n) (d : Fin 2 → ℤ) |
| (hd : ∀j, |d j| ≤ n) (ω : Noise) (s t : ℕ) (hs : s ≤ n) (ht : t ≤ n) (j : Fin 2) : |
| |baseTrans n d ω s j-baseTrans n d ω t j| ≤ (3/2)*|(s:ℝ)-t| := by |
| have hp := (position_lipschitz ω j (min s (n-s)) (min t (n-t))).trans |
| (div_le_div_of_nonneg_right (fold_time_lipschitz n s t hs ht) (by norm_num : (0:ℝ) ≤ 2)) |
| calc |
| _ = |((s:ℝ)-t)*((d j:ℝ)/(n:ℝ))+ |
| (position ω j (min s (n-s))-position ω j (min t (n-t)))| := by |
| unfold baseTrans; congr 1; ring |
| _ ≤ _ := abs_add_le _ _ |
| _ ≤ |(s:ℝ)-t| + |(s:ℝ)-t|/2 := add_le_add (by |
| rw [abs_mul] |
| exact (mul_le_mul_of_nonneg_left (drift_rate_le n hn (d j) (hd j)) |
| (abs_nonneg _)).trans_eq (mul_one _)) hp |
| _ = _ := by ring |
|
|
| lemma floor_abs_sub_le_two (x y : ℝ) (h : |x-y| ≤ 3/2) : |
| |⌊x⌋-⌊y⌋| ≤ (2:ℤ) := by |
| have hf := Int.floor_le x |
| have hg := Int.lt_floor_add_one y |
| have hf' := Int.floor_le y |
| have hg' := Int.lt_floor_add_one x |
| obtain ⟨hl,hu⟩ := abs_le.mp h |
| apply abs_le.mpr |
| constructor |
| · by_contra hn |
| have h' : ⌊y⌋-⌊x⌋ ≥ (3:ℤ) := by omega |
| have hh : (3:ℝ) ≤ (⌊y⌋:ℝ)-(⌊x⌋:ℝ) := by exact_mod_cast h' |
| linarith |
| · by_contra hn |
| have h' : ⌊x⌋-⌊y⌋ ≥ (3:ℤ) := by omega |
| have hh : (3:ℝ) ≤ (⌊x⌋:ℝ)-(⌊y⌋:ℝ) := by exact_mod_cast h' |
| linarith |
|
|
| lemma baseVertex_step (n : ℕ) (hn : 0 < n) (d : Fin 2 → ℤ) |
| (hd : ∀j, |d j| ≤ n) (ω : Noise) (t : ℕ) (ht : t < n) (j : Fin 3) : |
| |baseVertex n d ω (t+1) j-baseVertex n d ω t j| ≤ 2 := by |
| have hh (i : Fin 2) : |⌊baseTrans n d ω (t+1) i⌋-⌊baseTrans n d ω t i⌋| ≤ (2:ℤ) := by |
| apply floor_abs_sub_le_two |
| have h := baseTrans_lipschitz n hn d hd ω (t+1) t (by omega) (by omega) i |
| simpa only [Nat.cast_add,Nat.cast_one,add_sub_cancel_left,abs_one,mul_one] using h |
| fin_cases j |
| · norm_num [baseVertex] |
| · exact hh 0 |
| · exact hh 1 |
|
|
| lemma baseVertex_initial (n : ℕ) (d : Fin 2 → ℤ) (ω : Noise) : |
| baseVertex n d ω 0 = 0 := by |
| ext j |
| fin_cases j <;> simp [baseVertex,baseTrans,position] |
|
|
| lemma baseVertex_final (n : ℕ) (hn : 0 < n) (d : Fin 2 → ℤ) (ω : Noise) : |
| baseVertex n d ω n = ![(n:ℤ),d 0,d 1] := by |
| have hn0 : (n:ℝ) ≠ 0 := by exact_mod_cast (ne_of_gt hn) |
| ext j |
| fin_cases j <;> simp [baseVertex,baseTrans,position,mul_div_cancel_left₀ _ hn0] |
|
|
| def axisSteps (a b : ℤ) : List ℤ := |
| if a ≤ b then (List.range (b-a).toNat).map (fun k : ℕ ↦ a+(k:ℤ)+1) |
| else (List.range (a-b).toNat).map (fun k : ℕ ↦ a-(k:ℤ)-1) |
|
|
| lemma axisSteps_length (a b : ℤ) : (axisSteps a b).length = (b-a).natAbs := by |
| unfold axisSteps |
| split_ifs with h <;> simp only [List.length_map,List.length_range] |
| · have hh := Int.natAbs_of_nonneg (by omega : 0 ≤ b-a) |
| have hh' := Int.toNat_of_nonneg (by omega : 0 ≤ b-a) |
| omega |
| · rw [← Int.natAbs_neg,Int.neg_sub] |
| have hh := Int.natAbs_of_nonneg (by omega : 0 ≤ a-b) |
| have hh' := Int.toNat_of_nonneg (by omega : 0 ≤ a-b) |
| omega |
|
|
| lemma axisSteps_between (a b c : ℤ) (hc : c ∈ axisSteps a b) : |
| min a b ≤ c ∧ c ≤ max a b := by |
| unfold axisSteps at hc |
| split_ifs at hc with h |
| · obtain ⟨k,hk,rfl⟩ := List.mem_map.mp hc |
| have hk' := List.mem_range.mp hk |
| simp only [min_eq_left h,max_eq_right h] |
| omega |
| · obtain ⟨k,hk,rfl⟩ := List.mem_map.mp hc |
| have hk' := List.mem_range.mp hk |
| simp only [min_eq_right (by omega : b ≤ a),max_eq_left (by omega : b ≤ a)] |
| omega |
|
|
| lemma axisSteps_near_final (a b c : ℤ) (hc : c ∈ axisSteps a b) : |
| |c-b| ≤ |a-b| := by |
| obtain ⟨hl,hu⟩ := axisSteps_between a b c hc |
| rcases le_total a b with h|h |
| · rw [min_eq_left h] at hl |
| rw [max_eq_right h] at hu |
| rw [abs_of_nonpos (by omega : a-b ≤ 0),abs_of_nonpos (by omega : c-b ≤ 0)] |
| omega |
| · rw [min_eq_right h] at hl |
| rw [max_eq_left h] at hu |
| rw [abs_of_nonneg (by omega : 0 ≤ a-b),abs_of_nonneg (by omega : 0 ≤ c-b)] |
| omega |
|
|
| def refineStep (a b : Vertex) : List Vertex := |
| [![b 0,a 1,a 2]] ++ |
| (axisSteps (a 1) (b 1)).map (fun c ↦ ![b 0,c,a 2]) ++ |
| (axisSteps (a 2) (b 2)).map (fun c ↦ ![b 0,b 1,c]) |
|
|
| lemma refineStep_length (a b : Vertex) (h : ∀j, |b j-a j| ≤ 2) : |
| (refineStep a b).length ≤ 5 := by |
| simp only [refineStep,List.length_append,List.length_singleton,List.length_map,axisSteps_length] |
| have h1 := h 1 |
| have h2 := h 2 |
| have ha1 : (b 1-a 1).natAbs ≤ 2 := by |
| have hh : ((b 1-a 1).natAbs:ℤ) ≤ 2 := by simpa only [Int.natCast_natAbs] using h1 |
| exact_mod_cast hh |
| have ha2 : (b 2-a 2).natAbs ≤ 2 := by |
| have hh : ((b 2-a 2).natAbs:ℤ) ≤ 2 := by simpa only [Int.natCast_natAbs] using h2 |
| exact_mod_cast hh |
| omega |
|
|
| end HardSphere.DyadicSkeleton |
| end |
| end |
|
|
| end OAI |
|
|
