| import Mathlib |
| import OAI.Probability.Ballisticity.Geometry.WordCoordinate |
|
|
| namespace OAI |
|
|
| section |
| section |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology |
| namespace DirectionalTransience |
|
|
| lemma conditioned_word_spatial_strong_laws {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν] |
| (hue : UniformElliptic ν) (ℓ : Vector d) (hℓ : dot ℓ ℓ = 1) |
| (htrans : DirectionallyTransient ν ℓ) (e : Direction d) : |
| ∀ᵐ X ∂conditionedLaw ν ℓ, |
| Tendsto (fun n : ℕ => (∑ i ∈ Finset.range n, wordCoordinate e (regenerationWords ℓ X i))/n) |
| atTop (𝓝 (∫ Y, wordCoordinate e (firstWord ℓ Y) ∂conditionedLaw ν ℓ)) ∧ |
| Tendsto (fun n : ℕ => wordRadius (regenerationWords ℓ X n)/n) atTop (𝓝 0) := by |
| have hi := regenerationWords_independent ν ℓ htrans |
| have hd := regenerationWords_identDistrib ν ℓ htrans |
| have hmc : Measurable (wordCoordinate e) := measurable_of_countable _ |
| have hc := strong_law_ae_real (fun n X => wordCoordinate e (regenerationWords ℓ X n)) |
| (conditioned_wordCoordinate_integrable ν hue ℓ hℓ htrans e) |
| (fun i j hij => (hi.indepFun hij).comp hmc hmc) (fun i => (hd i).comp hmc) |
| have hr := strong_law_ae_real (fun n X => wordRadius (regenerationWords ℓ X n)) |
| (conditioned_wordRadius_integrable ν hue ℓ hℓ htrans) |
| (fun i j hij => (hi.indepFun hij).comp measurable_wordRadius measurable_wordRadius) |
| (fun i => (hd i).comp measurable_wordRadius) |
| filter_upwards [hc,hr] with X hX hR |
| exact ⟨hX, increment_sublinear_of_average _ _ hR⟩ |
|
|
| lemma increasing_cuts_index_tendsto (T K : ℕ → ℕ) (hT : StrictMono T) |
| (hK : ∀ n, T (K n) ≤ n ∧ n < T (K n+1)) : Tendsto K atTop atTop := by |
| apply tendsto_atTop.mpr |
| intro M |
| filter_upwards [eventually_ge_atTop (T M)] with n hn |
| by_contra hm |
| have hh := hT.monotone (show K n+1 ≤ M by omega) |
| exact (not_lt_of_ge (hh.trans hn)) (hK n).2 |
|
|
| lemma scalar_cut_interpolation (T : ℕ → ℕ) (hT : StrictMono T) (hT0 : T 0 = 0) |
| (Y f R : ℕ → ℝ) (m : ℝ) (hm : 0 < m) |
| (hY : ∀ n, Y (T n) = ∑ i ∈ Finset.range n, f i) |
| (herr : ∀ k n, T k ≤ n → n < T (k+1) → |Y n-Y (T k)| ≤ R k) |
| (hf : Tendsto (fun n : ℕ => (∑ i ∈ Finset.range n, f i)/n) atTop (𝓝 m)) |
| (hR : Tendsto (fun n : ℕ => R n/n) atTop (𝓝 0)) : Tendsto Y atTop atTop := by |
| choose K hK using increasing_cuts_cover T hT hT0 |
| have hKt := increasing_cuts_index_tendsto T K hT hK |
| have hh := (hf.sub hR).comp hKt |
| simp only [sub_zero] at hh |
| have hmul := hh.pos_mul_atTop hm (tendsto_natCast_atTop_atTop.comp hKt) |
| apply tendsto_atTop_mono' _ _ hmul |
| filter_upwards [hKt.eventually (eventually_gt_atTop (0 : ℕ))] with n hn |
| have hk : (K n : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr (ne_of_gt hn) |
| have he := neg_le_of_abs_le (herr (K n) n (hK n).1 (hK n).2) |
| simp only [Function.comp_apply, sub_mul, div_mul_cancel₀ _ hk] |
| rw [← hY] |
| linarith only [he] |
| |
| lemma regeneration_coordinate_sum {d : ℕ} (ℓ : Vector d) (e : Direction d) |
| (X : Path d) (hX : X ∈ RegenerationSupport ℓ) (n : ℕ) : |
| signedCoordinate e (X (regenerationTimes ℓ X n)) = |
| ∑ i ∈ Finset.range n, wordCoordinate e (regenerationWords ℓ X i) := by |
| induction n with |
| | zero => simp [hX.1, signedCoordinate] |
| | succ n ih => |
| rw [regenerationTimes_succ, regeneration_span ℓ X hX.1 hX.2 n _ (by rfl), |
| signedCoordinate_add, ih, Finset.sum_range_succ, wordCoordinate] |
| |
| lemma conditioned_coordinate_transience {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν] |
| (hue : UniformElliptic ν) (ℓ : Vector d) (hℓ : dot ℓ ℓ = 1) |
| (htrans : DirectionallyTransient ν ℓ) (e : Direction d) |
| (he : 0 < ∫ X, wordCoordinate e (firstWord ℓ X) ∂conditionedLaw ν ℓ) : |
| ∀ᵐ X ∂conditionedLaw ν ℓ, Tendsto (fun n => signedCoordinate e (X n)) atTop atTop := by |
| filter_upwards [conditioned_regenerationSupport ν ℓ htrans, |
| conditioned_word_spatial_strong_laws ν hue ℓ hℓ htrans e] with X hX hlim |
| apply scalar_cut_interpolation (regenerationTimes ℓ X) |
| (regenerationTimes_strictMono ℓ X hX.2) (regenerationTimes_zero ℓ X) |
| (fun n => signedCoordinate e (X n)) (fun n => wordCoordinate e (regenerationWords ℓ X n)) |
| (fun n => wordRadius (regenerationWords ℓ X n)) _ he |
| (regeneration_coordinate_sum ℓ e X hX) _ hlim.1 hlim.2 |
| intro k n hlo hhi |
| have hnk : n = regenerationTimes ℓ X k+(n-regenerationTimes ℓ X k) := by omega |
| have hlen : n-regenerationTimes ℓ X k ≤ (regenerationWords ℓ X k).length := by |
| rw [regenerationTimes_succ] at hhi |
| omega |
| have hh := regeneration_span ℓ X hX.1 hX.2 k _ hlen |
| rw [← hnk] at hh |
| rw [hh, signedCoordinate_add, add_sub_cancel_left] |
| exact (signedCoordinate_abs_le_norm _ _).trans (wordRadius_bound _ hlen) |
| |
| lemma conditioned_to_annealed_transience {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν] |
| (ℓ u : Vector d) (htrans : DirectionallyTransient ν ℓ) |
| (hu : ∀ᵐ X ∂conditionedLaw ν ℓ, X ∈ TransientPaths u) : DirectionallyTransient ν u := by |
| let B := NoDrop ℓ 0 ∩ (TransientPaths u)ᶜ |
| have hB : MeasurableSet B := (measurableSet_noDrop ℓ 0).inter (measurableSet_transientPaths u).compl |
| have hBD : B ⊆ NoDrop ℓ 0 := Set.inter_subset_left |
| have hcB : conditionedLaw ν ℓ B = 0 := |
| measure_mono_null Set.inter_subset_right (ae_iff.mp hu) |
| have haB : annealedLaw ν B = 0 := by |
| rw [conditionedLaw_apply_of_subset ν ℓ B hB hBD] at hcB |
| exact (mul_eq_zero.mp hcB).resolve_left (ENNReal.inv_ne_zero.mpr (measure_ne_top _ _)) |
| have hwords : ∀ᵐ X ∂annealedLaw ν, ∀ w : List (Direction d), |
| (∀ y ∈ wordDepartures 0 w, dot (realPosition y) ℓ < |
| dot (realPosition (wordPath 0 w w.length)) ℓ) → |
| X ∈ wordCylinder 0 w → |
| (fun j => X (w.length+j)-wordPath 0 w w.length) ∉ B := by |
| apply ae_all_iff.mpr |
| intro w |
| by_cases hw : ∀ y ∈ wordDepartures 0 w, dot (realPosition y) ℓ < |
| dot (realPosition (wordPath 0 w w.length)) ℓ |
| · have hz := annealed_record_suffix ν ℓ w hw B hB hBD |
| rw [haB, mul_zero] at hz |
| filter_upwards [measure_eq_zero_iff_ae_notMem.mp hz] with X hX _ hcy |
| exact fun hh => hX ⟨hh,hcy⟩ |
| · exact Filter.Eventually.of_forall fun _ h _ => (hw h).elim |
| filter_upwards [annealed_initial ν, annealed_nearest_neighbor ν, |
| annealed_trueRecords_unbounded ν ℓ htrans, hwords] with X h0 hnn hrec hwords |
| obtain ⟨n,_,hn⟩ := hrec 0 |
| obtain ⟨w,hw,hcy⟩ := exists_word_prefix X hnn n |
| rw [h0] at hcy |
| have hwend : wordPath 0 w w.length = X n := by rw [← hw]; exact (hcy _ le_rfl).symm |
| have hwrec : ∀ y ∈ wordDepartures 0 w, dot (realPosition y) ℓ < |
| dot (realPosition (wordPath 0 w w.length)) ℓ := by |
| intro y hy |
| obtain ⟨j,hj,rfl⟩ := (wordDepartures_mem_iff 0 y w).mp hy |
| rw [← hcy j hj.le, hwend] |
| exact hn.1 j (by omega) |
| have hnot := hwords w hwrec hcy |
| have hD : (fun j => X (w.length+j)-wordPath 0 w w.length) ∈ NoDrop ℓ 0 := by |
| intro j |
| rw [hwend, hw, dot_realPosition_sub] |
| have hh := hn.2 j |
| simpa only [dot, realPosition, Pi.zero_apply, Int.cast_zero, zero_mul, Finset.sum_const_zero, |
| sub_nonneg] using hh |
| have ht : (fun j => X (n+j)-X n) ∈ TransientPaths u := by |
| by_contra hh |
| apply hnot |
| refine ⟨hD, ?_⟩ |
| change (fun j => X (w.length+j)-wordPath 0 w w.length) ∉ TransientPaths u |
| rw [hwend, hw] |
| exact hh |
| have hraw : (fun j => X (n+j)) ∈ TransientPaths u := by |
| change (fun j => X (n+j)) ∈ (fun Z : Path d => fun j => Z j-X n) ⁻¹' TransientPaths u at ht |
| rwa [transientPaths_translation] at ht |
| change Tendsto (fun j => dot (realPosition (X j)) u) atTop atTop |
| change Tendsto (fun j => dot (realPosition (X (n+j))) u) atTop atTop at hraw |
| exact (tendsto_add_atTop_iff_nat n).mp (by simpa only [Nat.add_comm] using hraw) |
|
|
| lemma dot_comm {d : ℕ} (v w : Vector d) : dot v w = dot w v := by |
| simp only [dot, mul_comm] |
|
|
| lemma dot_signed_direction {d : ℕ} (e : Direction d) (x : Lattice d) : |
| dot (realPosition x) (realPosition (step e)) = signedCoordinate e x := by |
| rw [dot_comm, dot_step] |
| rfl |
|
|
| lemma signed_direction_unit {d : ℕ} (e : Direction d) : |
| dot (realPosition (step e)) (realPosition (step e)) = 1 := by |
| rw [dot_step] |
| simp only [realPosition,step,ite_true,Int.cast_ite,Int.cast_one,Int.cast_neg] |
| cases e.2 <;> norm_num |
|
|
| lemma exists_transient_signed_coordinate {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν] |
| (hue : UniformElliptic ν) (ℓ : Vector d) (hℓ : dot ℓ ℓ = 1) |
| (htrans : DirectionallyTransient ν ℓ) : ∃ e : Direction d, |
| DirectionallyTransient ν (realPosition (step e)) := by |
| obtain ⟨e,he⟩ := conditioned_coordinate_positive_mean ν hue ℓ hℓ htrans |
| refine ⟨e, conditioned_to_annealed_transience ν ℓ (realPosition (step e)) htrans ?_⟩ |
| have hh := conditioned_coordinate_transience ν hue ℓ hℓ htrans e he |
| simpa only [TransientPaths, Set.mem_ofPred_eq, dot_signed_direction] using hh |
|
|
| noncomputable def fixedQuenchedKernel {d : ℕ} (x : Lattice d) : |
| Kernel (Environment d) (Path d) := |
| quenchedKernel.comap (fun ω => (ω,x)) (measurable_id.prodMk measurable_const) |
|
|
| instance fixedQuenchedKernel_markov {d : ℕ} (x : Lattice d) : |
| IsMarkovKernel (fixedQuenchedKernel x) := by unfold fixedQuenchedKernel; infer_instance |
|
|
| noncomputable def sharedPairKernel {d : ℕ} (x y : Lattice d) : |
| Kernel (Environment d) (Path d × Path d) := |
| (fixedQuenchedKernel x).prod (fixedQuenchedKernel y) |
|
|
| instance sharedPairKernel_markov {d : ℕ} (x y : Lattice d) : |
| IsMarkovKernel (sharedPairKernel x y) := by unfold sharedPairKernel; infer_instance |
|
|
| noncomputable def sharedPairLaw {d : ℕ} (ν : Measure (Row d)) (x y : Lattice d) : |
| Measure (Path d × Path d) := sharedPairKernel x y ∘ₘ environmentLaw ν |
|
|
| instance sharedPairLaw_probability {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν] |
| (x y : Lattice d) : IsProbabilityMeasure (sharedPairLaw ν x y) := by |
| unfold sharedPairLaw |
| infer_instance |
|
|
| noncomputable def sharedNoDropMass {d : ℕ} (ν : Measure (Row d)) (ℓ : Vector d) |
| (x y : Lattice d) : ℝ≥0∞ := |
| ∫⁻ ω, noDropQuenched ℓ x ω * noDropQuenched ℓ y ω ∂environmentLaw ν |
|
|
| lemma sharedPairLaw_rectangle {d : ℕ} (ν : Measure (Row d)) (x y : Lattice d) |
| (A B : Set (Path d)) (hA : MeasurableSet A) (hB : MeasurableSet B) : |
| sharedPairLaw ν x y (A ×ˢ B) = |
| ∫⁻ ω, quenchedKernel (ω,x) A * quenchedKernel (ω,y) B ∂environmentLaw ν := by |
| rw [sharedPairLaw, Measure.bind_apply (hA.prod hB) (Kernel.aemeasurable _)] |
| apply lintegral_congr |
| intro ω |
| rw [sharedPairKernel, Kernel.prod_apply, Measure.prod_prod] |
| rfl |
|
|
| lemma sharedNoDropMass_eq {d : ℕ} (ν : Measure (Row d)) (ℓ : Vector d) (x y : Lattice d) : |
| sharedNoDropMass ν ℓ x y = sharedPairLaw ν x y (NoDrop ℓ x ×ˢ NoDrop ℓ y) := |
| (sharedPairLaw_rectangle ν x y _ _ (measurableSet_noDrop ℓ x) (measurableSet_noDrop ℓ y)).symm |
|
|
| lemma sharedNoDropMass_le_one {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν] |
| (ℓ : Vector d) (x y : Lattice d) : sharedNoDropMass ν ℓ x y ≤ 1 := by |
| rw [sharedNoDropMass_eq] |
| exact prob_le_one |
|
|
| lemma sharedNoDropMass_uniform_positive {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν] |
| (hue : UniformElliptic ν) (ℓ : Vector d) (hℓ : dot ℓ ℓ = 1) |
| (htrans : DirectionallyTransient ν ℓ) : |
| ∃ c : ℝ≥0∞, 0 < c ∧ ∀ x y : Lattice d, c ≤ sharedNoDropMass ν ℓ x y := by |
| obtain ⟨s,hs,_,hsmall⟩ := positive_random_small_set (environmentLaw ν) (noDropQuenched ℓ 0) |
| (measurable_noDropQuenched ℓ 0) |
| ((quenched_noDrop_positive_of_directionallyTransient ν hue ℓ hℓ htrans).mono fun _ h => h 0) |
| refine ⟨(s : ℝ≥0∞)^2 / 2, ENNReal.div_pos (pow_ne_zero _ (by exact_mod_cast hs.ne')) (by norm_num), ?_⟩ |
| intro x y |
| let μ := environmentLaw ν |
| let A := {ω | noDropQuenched ℓ x ω ≤ 2*(s : ℝ≥0∞)} |
| let B := {ω | noDropQuenched ℓ y ω ≤ 2*(s : ℝ≥0∞)} |
| have hA : MeasurableSet A := measurableSet_le (measurable_noDropQuenched ℓ x) measurable_const |
| have hB : MeasurableSet B := measurableSet_le (measurable_noDropQuenched ℓ y) measurable_const |
| have hsa : μ A < 1/4 := by |
| rw [show μ A = environmentLaw ν {ω | noDropQuenched ℓ 0 ω ≤ 2*(s : ℝ≥0∞)} from |
| noDropQuenched_small_translation ν ℓ x _] |
| exact hsmall |
| have hsb : μ B < 1/4 := by |
| rw [show μ B = environmentLaw ν {ω | noDropQuenched ℓ 0 ω ≤ 2*(s : ℝ≥0∞)} from |
| noDropQuenched_small_translation ν ℓ y _] |
| exact hsmall |
| have hsa' : μ.real A < 1/4 := by |
| have hh := (ENNReal.toReal_lt_toReal (measure_ne_top μ A) (by norm_num)).mpr hsa |
| norm_num at hh |
| exact hh |
| have hsb' : μ.real B < 1/4 := by |
| have hh := (ENNReal.toReal_lt_toReal (measure_ne_top μ B) (by norm_num)).mpr hsb |
| norm_num at hh |
| exact hh |
| have hgood : (1 : ℝ≥0∞)/2 ≤ μ (A ∪ B)ᶜ := by |
| apply (ENNReal.toReal_le_toReal (by norm_num) (measure_ne_top μ _)).mp |
| change ((1 : ℝ≥0∞)/2).toReal ≤ μ.real (A ∪ B)ᶜ |
| rw [probReal_compl_eq_one_sub (hA.union hB)] |
| norm_num only [ENNReal.toReal_div, ENNReal.toReal_one, ENNReal.toReal_ofNat] |
| linarith only [measureReal_union_le (μ := μ) A B, hsa', hsb'] |
| have hsub : (A ∪ B)ᶜ ⊆ {ω | (s : ℝ≥0∞)^2 ≤ |
| noDropQuenched ℓ x ω * noDropQuenched ℓ y ω} := by |
| intro ω hω |
| have hx : ¬noDropQuenched ℓ x ω ≤ 2*(s : ℝ≥0∞) := fun h => hω (Or.inl h) |
| have hy : ¬noDropQuenched ℓ y ω ≤ 2*(s : ℝ≥0∞) := fun h => hω (Or.inr h) |
| have hs2 : (s : ℝ≥0∞) ≤ 2*(s : ℝ≥0∞) := by |
| simpa only [one_mul] using mul_le_mul_left (by norm_num : (1 : ℝ≥0∞) ≤ 2) (s : ℝ≥0∞) |
| rw [pow_two] |
| exact mul_le_mul' (hs2.trans (le_of_not_ge hx)) (hs2.trans (le_of_not_ge hy)) |
| calc |
| (s : ℝ≥0∞)^2/2 = (s : ℝ≥0∞)^2 * (1/2) := by rw [div_eq_mul_inv, one_div] |
| _ ≤ (s : ℝ≥0∞)^2 * μ {ω | (s : ℝ≥0∞)^2 ≤ |
| noDropQuenched ℓ x ω * noDropQuenched ℓ y ω} := |
| mul_le_mul_right (hgood.trans (measure_mono hsub)) _ |
| _ ≤ sharedNoDropMass ν ℓ x y := |
| mul_meas_ge_le_lintegral₀ |
| ((measurable_noDropQuenched ℓ x).mul (measurable_noDropQuenched ℓ y)).aemeasurable _ |
|
|
| noncomputable def sharedConditionedPairLaw {d : ℕ} (ν : Measure (Row d)) |
| (ℓ : Vector d) (x y : Lattice d) : Measure (Path d × Path d) := |
| (sharedNoDropMass ν ℓ x y)⁻¹ • |
| (sharedPairLaw ν x y).restrict (NoDrop ℓ x ×ˢ NoDrop ℓ y) |
|
|
| lemma sharedConditionedPairLaw_probability {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν] |
| (ℓ : Vector d) (x y : Lattice d) (hp : sharedNoDropMass ν ℓ x y ≠ 0) : |
| IsProbabilityMeasure (sharedConditionedPairLaw ν ℓ x y) := by |
| constructor |
| simp only [sharedConditionedPairLaw, Measure.smul_apply, Measure.restrict_apply MeasurableSet.univ, |
| Set.univ_inter, smul_eq_mul, ← sharedNoDropMass_eq] |
| exact ENNReal.inv_mul_cancel hp (ne_of_lt ((sharedNoDropMass_le_one ν ℓ x y).trans_lt (by simp))) |
|
|
| noncomputable def annealedFrom {d : ℕ} (ν : Measure (Row d)) (x : Lattice d) : |
| Measure (Path d) := fixedQuenchedKernel x ∘ₘ environmentLaw ν |
|
|
| instance annealedFrom_probability {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν] |
| (x : Lattice d) : IsProbabilityMeasure (annealedFrom ν x) := by |
| unfold annealedFrom |
| infer_instance |
|
|
| lemma annealedFrom_apply {d : ℕ} (ν : Measure (Row d)) (x : Lattice d) |
| (A : Set (Path d)) (hA : MeasurableSet A) : |
| annealedFrom ν x A = ∫⁻ ω, quenchedKernel (ω,x) A ∂environmentLaw ν := by |
| rw [annealedFrom, Measure.bind_apply hA (Kernel.aemeasurable _)] |
| rfl |
|
|
| lemma annealedFrom_noDrop {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν] |
| (ℓ : Vector d) (x : Lattice d) : |
| annealedFrom ν x (NoDrop ℓ x) = annealedLaw ν (NoDrop ℓ 0) := by |
| rw [annealedFrom_apply ν x _ (measurableSet_noDrop ℓ x)] |
| exact annealed_noDrop_translation ν ℓ x |
|
|
| noncomputable def conditionedFrom {d : ℕ} (ν : Measure (Row d)) (ℓ : Vector d) |
| (x : Lattice d) : Measure (Path d) := |
| (annealedLaw ν (NoDrop ℓ 0))⁻¹ • (annealedFrom ν x).restrict (NoDrop ℓ x) |
|
|
| lemma conditionedFrom_probability {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν] |
| (ℓ : Vector d) (x : Lattice d) (hp : annealedLaw ν (NoDrop ℓ 0) ≠ 0) : |
| IsProbabilityMeasure (conditionedFrom ν ℓ x) := by |
| constructor |
| simp only [conditionedFrom, Measure.smul_apply, Measure.restrict_apply MeasurableSet.univ, |
| Set.univ_inter, smul_eq_mul, annealedFrom_noDrop] |
| exact ENNReal.inv_mul_cancel hp (measure_ne_top _ _) |
|
|
| lemma sharedConditionedPairLaw_fst_le {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν] |
| (ℓ : Vector d) (x y : Lattice d) (A : Set (Path d)) (hA : MeasurableSet A) |
| (hp : annealedLaw ν (NoDrop ℓ 0) ≠ 0) : |
| sharedConditionedPairLaw ν ℓ x y (Prod.fst ⁻¹' A) ≤ |
| (sharedNoDropMass ν ℓ x y)⁻¹ * annealedLaw ν (NoDrop ℓ 0) * |
| conditionedFrom ν ℓ x A := by |
| rw [sharedConditionedPairLaw, Measure.smul_apply, |
| Measure.restrict_apply (hA.preimage measurable_fst)] |
| have he : Prod.fst ⁻¹' A ∩ (NoDrop ℓ x ×ˢ NoDrop ℓ y) = |
| (A ∩ NoDrop ℓ x) ×ˢ NoDrop ℓ y := by |
| ext z |
| exact and_assoc.symm |
| rw [he, sharedPairLaw_rectangle ν x y _ _ (hA.inter (measurableSet_noDrop ℓ x)) |
| (measurableSet_noDrop ℓ y)] |
| simp only [smul_eq_mul, conditionedFrom, Measure.smul_apply, |
| Measure.restrict_apply hA] |
| rw [← mul_assoc, mul_assoc _ (annealedLaw ν (NoDrop ℓ 0)), |
| ENNReal.mul_inv_cancel hp (measure_ne_top _ _), mul_one] |
| apply mul_le_mul_right |
| rw [annealedFrom_apply ν x _ (hA.inter (measurableSet_noDrop ℓ x))] |
| exact lintegral_mono fun ω => mul_le_of_le_one_right' prob_le_one |
|
|
| lemma sharedConditionedPairLaw_snd_le {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν] |
| (ℓ : Vector d) (x y : Lattice d) (A : Set (Path d)) (hA : MeasurableSet A) |
| (hp : annealedLaw ν (NoDrop ℓ 0) ≠ 0) : |
| sharedConditionedPairLaw ν ℓ x y (Prod.snd ⁻¹' A) ≤ |
| (sharedNoDropMass ν ℓ x y)⁻¹ * annealedLaw ν (NoDrop ℓ 0) * |
| conditionedFrom ν ℓ y A := by |
| rw [sharedConditionedPairLaw, Measure.smul_apply, |
| Measure.restrict_apply (hA.preimage measurable_snd)] |
| have he : Prod.snd ⁻¹' A ∩ (NoDrop ℓ x ×ˢ NoDrop ℓ y) = |
| NoDrop ℓ x ×ˢ (A ∩ NoDrop ℓ y) := by |
| ext z |
| simp only [Set.mem_inter_iff, Set.mem_preimage, Set.mem_prod] |
| tauto |
| rw [he, sharedPairLaw_rectangle ν x y _ _ (measurableSet_noDrop ℓ x) |
| (hA.inter (measurableSet_noDrop ℓ y))] |
| simp only [smul_eq_mul, conditionedFrom, Measure.smul_apply, |
| Measure.restrict_apply hA] |
| rw [← mul_assoc, mul_assoc _ (annealedLaw ν (NoDrop ℓ 0)), |
| ENNReal.mul_inv_cancel hp (measure_ne_top _ _), mul_one] |
| apply mul_le_mul_right |
| rw [annealedFrom_apply ν y _ (hA.inter (measurableSet_noDrop ℓ y))] |
| exact lintegral_mono fun ω => mul_le_of_le_one_left' prob_le_one |
|
|
| lemma shared_pair_word_suffix {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν] |
| (x y : Lattice d) (w v : List (Direction d)) (T : Set (Lattice d)) |
| (hx : wordPath x w w.length ∈ T) (hy : wordPath y v v.length ∈ T) |
| (hdis : Disjoint ((wordDepartures x w : Set (Lattice d)) ∪ wordDepartures y v) T) |
| (A B : Set (Path d)) (hA : MeasurableSet A) (hB : MeasurableSet B) |
| (hAT : A ⊆ Stay T) (hBT : B ⊆ Stay T) : |
| sharedPairLaw ν x y |
| (((fun X : Path d => fun j => X (w.length+j)) ⁻¹' A ∩ wordCylinder x w) ×ˢ |
| ((fun X : Path d => fun j => X (v.length+j)) ⁻¹' B ∩ wordCylinder y v)) = |
| sharedPairLaw ν x y (wordCylinder x w ×ˢ wordCylinder y v) * |
| sharedPairLaw ν (wordPath x w w.length) (wordPath y v v.length) (A ×ˢ B) := by |
| let S : Set (Lattice d) := (wordDepartures x w : Set (Lattice d)) ∪ wordDepartures y v |
| have hmA : MeasurableSet ((fun X : Path d => fun j => X (w.length+j)) ⁻¹' A ∩ |
| wordCylinder x w) := (hA.preimage (by fun_prop)).inter (measurableSet_wordCylinder x w) |
| have hmB : MeasurableSet ((fun X : Path d => fun j => X (v.length+j)) ⁻¹' B ∩ |
| wordCylinder y v) := (hB.preimage (by fun_prop)).inter (measurableSet_wordCylinder y v) |
| have hw (ω : Environment d) : quenchedKernel (ω,x) |
| ((fun X : Path d => fun j => X (w.length+j)) ⁻¹' A ∩ wordCylinder x w) = |
| ENNReal.ofReal (wordWeight ω x w) * quenchedKernel (ω, wordPath x w w.length) A := by |
| rw [show wordCylinder x w = pathCylinder (wordPath x w) w.length from rfl, |
| quenched_prefix_future ω x (wordPath x w) (wordPath_zero x w) w.length hA] |
| rw [show pathCylinder (wordPath x w) w.length = wordCylinder x w from rfl, |
| quenched_wordCylinder] |
| have hv (ω : Environment d) : quenchedKernel (ω,y) |
| ((fun X : Path d => fun j => X (v.length+j)) ⁻¹' B ∩ wordCylinder y v) = |
| ENNReal.ofReal (wordWeight ω y v) * quenchedKernel (ω, wordPath y v v.length) B := by |
| rw [show wordCylinder y v = pathCylinder (wordPath y v) v.length from rfl, |
| quenched_prefix_future ω y (wordPath y v) (wordPath_zero y v) v.length hB] |
| rw [show pathCylinder (wordPath y v) v.length = wordCylinder y v from rfl, |
| quenched_wordCylinder] |
| rw [sharedPairLaw_rectangle ν x y _ _ hmA hmB] |
| simp_rw [hw,hv, mul_mul_mul_comm] |
| have hind := lintegral_mul_eq_lintegral_mul_lintegral_of_independent_measurableSpace |
| (rowSigma_le S) (rowSigma_le T) (environment_indep_rows ν hdis) |
| (((measurable_wordWeight_on x w (fun _ hz => Or.inl hz)).ennreal_ofReal).mul |
| ((measurable_wordWeight_on y v (fun _ hz => Or.inr hz)).ennreal_ofReal)) |
| ((measurable_quenched_stay_event_rows T _ hx A hA hAT).mul |
| (measurable_quenched_stay_event_rows T _ hy B hB hBT)) |
| simp only [Pi.mul_apply] at hind |
| rw [hind] |
| rw [sharedPairLaw_rectangle ν x y _ _ (measurableSet_wordCylinder x w) |
| (measurableSet_wordCylinder y v), |
| sharedPairLaw_rectangle ν (wordPath x w w.length) (wordPath y v v.length) _ _ hA hB] |
| simp only [quenched_wordCylinder] |
|
|
| lemma noDrop_real_integral_translation {d : ℕ} (ν : Measure (Row d)) |
| [IsProbabilityMeasure ν] (ℓ : Vector d) (x : Lattice d) : |
| (∫ ω, (noDropQuenched ℓ x ω).toReal ∂environmentLaw ν) = |
| ∫ ω, (noDropQuenched ℓ 0 ω).toReal ∂environmentLaw ν := by |
| conv_lhs => enter [2, ω]; rw [noDropQuenched_translation ℓ ω x] |
| have h := integral_map (μ := environmentLaw ν) |
| (show AEMeasurable (fun ω : Environment d => fun a => ω (x + a)) (environmentLaw ν) from |
| (by fun_prop : Measurable (fun ω : Environment d => fun a => ω (x + a))).aemeasurable) |
| ((measurable_noDropQuenched ℓ 0).ennreal_toReal.aestronglyMeasurable) |
| rw [environment_translation] at h |
| exact h.symm |
|
|
| end DirectionalTransience |
| end |
| end |
|
|
| end OAI |
|
|
