| import OAI.Probability.LatticePassage.LocalPassage |
|
|
| namespace OAI |
|
|
| namespace CompanionFPP |
| open MeasureTheory Real |
|
|
| lemma integrable_trail_exp {x y : Vertex} (p : lattice.Walk x y) (hp : p.IsTrail) : |
| Integrable (fun ω : Environment => exp (pathCost ω p / 2)) environmentLaw := by |
| apply (lintegral_ofReal_ne_top_iff_integrable (by fun_prop) |
| (by filter_upwards [] with ω; positivity)).mp |
| rw [trail_positive_moment p hp] |
| finiteness |
|
|
| lemma integral_trail_exp {x y : Vertex} (p : lattice.Walk x y) (hp : p.IsTrail) : |
| (∫ ω : Environment, exp (pathCost ω p / 2) ∂environmentLaw) = (2 : ℝ)^p.length := by |
| rw [integral_eq_lintegral_of_nonneg_ae (by filter_upwards [] with ω; positivity) |
| (by fun_prop), trail_positive_moment p hp] |
| simp |
|
|
| lemma integrable_trail_cost {x y : Vertex} (p : lattice.Walk x y) (hp : p.IsTrail) : |
| Integrable (fun ω : Environment => pathCost ω p) environmentLaw := by |
| apply ((integrable_trail_exp p hp).const_mul 2).mono' (by fun_prop) |
| filter_upwards [all_edge_weights_positive] with ω hω |
| rw [Real.norm_eq_abs, abs_of_nonneg (pathCost_nonneg ω (fun e => (hω e).le) p)] |
| have he := add_one_le_exp (pathCost ω p / 2) |
| linarith |
|
|
| lemma localPassageTime_le_pathCost (ω : Environment) {x y : Vertex} {R : ℕ} |
| (p : lattice.Walk x y) (hp : p.IsPath) (hl : p.length < R) : |
| localPassageTime ω x y R ≤ pathCost ω p := |
| csInf_le (local_costs_finite ω x y R).bddBelow ⟨p,hp,hl,rfl⟩ |
|
|
| lemma passageTime_le_localPassageTime (ω : Environment) (hω : ∀ e, 0 ≤ ω e) |
| (x y : Vertex) (R : ℕ) (hR : latticeDistance x y < R) : |
| passageTime ω x y ≤ localPassageTime ω x y R := by |
| obtain ⟨p,_,_,hp⟩ := local_geodesic_exists ω x y R hR |
| rw [← hp] |
| exact passageTime_le_pathCost ω hω p |
|
|
| theorem integrable_localPassageTime (x y : Vertex) (R : ℕ) |
| (hR : latticeDistance x y < R) : |
| Integrable (fun ω : Environment => localPassageTime ω x y R) environmentLaw := by |
| obtain ⟨p,hp,hl⟩ := coordinate_path x y |
| apply (integrable_trail_cost p hp.isTrail).mono' (by fun_prop) |
| filter_upwards [all_edge_weights_positive] with ω hω |
| have ht := passageTime_nonneg ω (fun e => (hω e).le) (lattice_walk x y) |
| have hn := passageTime_le_localPassageTime ω (fun e => (hω e).le) x y R hR |
| rw [Real.norm_eq_abs, abs_of_nonneg (ht.trans hn)] |
| exact localPassageTime_le_pathCost ω p hp (hl.trans_lt hR) |
|
|
| private lemma rare_cost_pointwise (S u : ℝ) (hu : 0 ≤ u) (P : Prop) [Decidable P] : |
| (if P then S else 0) ≤ (if P then u else 0) + 4*exp (-u/4)*exp (S/2) := by |
| by_cases hP : P |
| · simp only [ite_eq_left hP] |
| by_cases hs : S ≤ u |
| · have : 0 ≤ 4*exp (-u/4)*exp (S/2) := by positivity |
| linarith |
| · have he := add_one_le_exp (S/4) |
| have he' : exp (S/4) ≤ exp (-u/4 + S/2) := by |
| rw [exp_le_exp] |
| linarith |
| rw [mul_assoc, ← exp_add] |
| linarith |
| · simp only [ite_eq_right hP, zero_add] |
| positivity |
|
|
| theorem rare_cost_integral {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) |
| [IsFiniteMeasure μ] (S : Ω → ℝ) (hS : Integrable S μ) |
| (he : Integrable (fun ω => exp (S ω / 2)) μ) (F : Set Ω) (hF : MeasurableSet F) |
| (u : ℝ) (hu : 0 ≤ u) : |
| (∫ ω, F.indicator S ω ∂μ) ≤ |
| u * μ.real F + 4*exp (-u/4) * (∫ ω, exp (S ω/2) ∂μ) := by |
| classical |
| have hbound := integral_mono_ae (hS.indicator hF) |
| (((integrable_const u).indicator hF).add (he.const_mul (4*exp (-u/4)))) |
| (Filter.Eventually.of_forall (fun ω => rare_cost_pointwise (S ω) u hu (ω ∈ F))) |
| simp only [Pi.add_apply] at hbound |
| rw [integral_add ((integrable_const u).indicator hF) (he.const_mul (4*exp (-u/4))), |
| integral_const_mul, integral_indicator_const u hF] at hbound |
| simpa [smul_eq_mul, mul_comm] using hbound |
|
|
| theorem localPassageTime_mean_error (x y : Vertex) (R : ℕ) (hR : 1 ≤ R) |
| (hscale : 40*latticeDistance x y ≤ R) : |
| (∫ ω : Environment, localPassageTime ω x y R - passageTime ω x y ∂environmentLaw) ≤ |
| (R : ℝ) * ((11/3 : ℝ)*exp (-(log 2/40)*R)) + |
| 4*exp (-(R : ℝ)/4)*(2 : ℝ)^latticeDistance x y := by |
| classical |
| have hd : latticeDistance x y < R := by omega |
| obtain ⟨p,hp,hl⟩ := coordinate_path x y |
| let F := {ω : Environment | localPassageTime ω x y R ≠ passageTime ω x y} |
| have hF : MeasurableSet F := (measurableSet_eq_fun (measurable_localPassageTime x y R) |
| (measurable_passageTime x y)).compl |
| have hcost := integrable_trail_cost p hp.isTrail |
| have hb : (∫ ω : Environment, localPassageTime ω x y R - passageTime ω x y ∂environmentLaw) ≤ |
| ∫ ω, F.indicator (fun ω => pathCost ω p) ω ∂environmentLaw := by |
| apply integral_mono_ae ((integrable_localPassageTime x y R hd).sub (integrable_passageTime x y)) |
| (hcost.indicator hF) |
| filter_upwards [all_edge_weights_positive] with ω hω |
| simp only [Pi.sub_apply] |
| by_cases hf : ω ∈ F |
| · rw [Set.indicator_of_mem hf] |
| have h₁ := localPassageTime_le_pathCost ω p hp (hl.trans_lt hd) |
| have h₂ := passageTime_nonneg ω (fun e => (hω e).le) (lattice_walk x y) |
| linarith |
| · rw [Set.indicator_of_notMem hf] |
| have heq : localPassageTime ω x y R = passageTime ω x y := not_not.mp hf |
| rw [heq, sub_self] |
| apply hb.trans |
| have hm := rare_cost_integral environmentLaw (fun ω => pathCost ω p) hcost |
| (integrable_trail_exp p hp.isTrail) F hF (R : ℝ) (by positivity) |
| rw [integral_trail_exp p hp.isTrail] at hm |
| apply hm.trans |
| apply add_le_add |
| · exact mul_le_mul_of_nonneg_left (localPassageTime_failure_probability x y R hR hscale) |
| (Nat.cast_nonneg _) |
| · gcongr |
| norm_num |
|
|
| theorem localPassageTime_mean_error_exponential (x y : Vertex) (R : ℕ) (hR : 1 ≤ R) |
| (hscale : 40*latticeDistance x y ≤ R) : |
| (∫ ω : Environment, localPassageTime ω x y R - passageTime ω x y ∂environmentLaw) ≤ |
| ((11/3 : ℝ)*R + 4) * exp (-(log 2/40)*R) := by |
| apply (localPassageTime_mean_error x y R hR hscale).trans |
| have hn : 0 ≤ (R : ℝ) := Nat.cast_nonneg _ |
| have hl : 40*(latticeDistance x y : ℝ) ≤ R := by exact_mod_cast hscale |
| have hlog : log (2 : ℝ) ≤ 1 := by |
| have := log_le_sub_one_of_pos (by norm_num : (0 : ℝ) < 2) |
| linarith |
| have hpow : (2 : ℝ)^latticeDistance x y = |
| exp ((latticeDistance x y : ℝ)*log 2) := by |
| rw [exp_nat_mul, exp_log (by norm_num : (0 : ℝ) < 2)] |
| have hb : exp (-(R : ℝ)/4) * (2 : ℝ)^latticeDistance x y ≤ |
| exp (-(log 2/40)*R) := by |
| rw [hpow, ← exp_add, exp_le_exp] |
| have hd : 0 ≤ (latticeDistance x y : ℝ) := Nat.cast_nonneg _ |
| nlinarith |
| nlinarith |
|
|
| end CompanionFPP |
|
|
| end OAI |
|
|
