Download data/lean/OAI/Probability/JammingConcavity/CascadePathCoordinates.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 31.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/JammingConcavity/CascadePathCoordinates.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/JammingConcavity/CascadePathCoordinates.lean
-
curl -L -o CascadePathCoordinates.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/JammingConcavity/CascadePathCoordinates.lean
31.9 kB
| import Mathlib | |
| import OAI.Probability.JammingConcavity.FamilyPositiveTotal | |
| namespace OAI | |
| /-! Cascade Path Coordinates. -/ | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory Set | |
| open scoped NNReal ENNReal | |
| open Set Filter | |
| open scoped Topology | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped ENNReal NNReal Topology BigOperators | |
| open MeasureTheory Filter Set | |
| open scoped ENNReal NNReal BigOperators | |
| open MeasureTheory ProbabilityTheory Set Filter | |
| open scoped ENNReal NNReal Topology | |
| open scoped NNReal ENNReal Topology | |
| open scoped NNReal Topology | |
| open Set | |
| open Set Filter MeasureTheory | |
| open scoped BigOperators | |
| open scoped Topology NNReal | |
| open scoped Topology BigOperators | |
| open scoped ENNReal NNReal | |
| open MeasureTheory Set | |
| open MeasureTheory ProbabilityTheory | |
| open scoped ENNReal NNReal BigOperators Classical | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped ENNReal NNReal Topology BigOperators | |
| open Classical | |
| namespace MicroscopicJamming | |
| def cascadePathIndex : (k : β) β CascadePath k β Fin k β CascadeMarkIndex k | |
| | 0, _, j => Fin.elim0 j | |
| | k+1, β, j => Fin.cases (β.1.1,β.1.2,none) | |
| (fun j => (β.1.1,β.1.2,some (cascadePathIndex k β.2 j))) j | |
| lemma cascadePathIndex_depth (k : β) (β : CascadePath k) (j : Fin k) : | |
| cascadeMarkDepth k (cascadePathIndex k β j) = j := by | |
| induction k with | |
| | zero => exact Fin.elim0 j | |
| | succ k ih => | |
| refine Fin.cases ?_ (fun i => ?_) j | |
| Β· rfl | |
| Β· change cascadeMarkDepth k (cascadePathIndex k β.2 i)+1 = i.val+1 | |
| rw [ih] | |
| lemma cascadePathIndex_injective (k : β) (β : CascadePath k) : | |
| Function.Injective (cascadePathIndex k β) := by | |
| intro i j h | |
| apply Fin.ext | |
| simpa only [cascadePathIndex_depth] using congrArg (cascadeMarkDepth k) h | |
| lemma familyPathMark_zip {E : Type} [AddCommMonoid E] (k : β) (x : E) | |
| (Ο : CascadeTree k) (y : CascadeMarkTree E k) (β : CascadePath k) : | |
| familyPathMark k x (zipCascade k (Ο,y)) β = | |
| x+β j : Fin k, cascadeMarkCoordinates k y (cascadePathIndex k β j) := by | |
| induction k generalizing x with | |
| | zero => simp [familyPathMark] | |
| | succ k ih => | |
| change familyPathMark k (x+(y β.1.1 β.1.2).1) | |
| (zipCascade k (((Ο β.1.1).2 β.1.2).2,(y β.1.1 β.1.2).2)) β.2 = _ | |
| rw [ih, Fin.sum_univ_succ] | |
| simp only [cascadePathIndex] | |
| exact add_assoc _ _ _ | |
| lemma familyPathMark_coordinates {E : Type} [AddCommMonoid E] (k : β) (x : E) | |
| (Ο : CascadeTree k) (y : CascadeMarkTree E k) (β : CascadePath k) : | |
| familyPathMark k x (zipCascade k (Ο,y)) β = | |
| x+β i β Finset.univ.image (cascadePathIndex k β), cascadeMarkCoordinates k y i := by | |
| rw [familyPathMark_zip, Finset.sum_image] | |
| exact fun i _ j _ h => cascadePathIndex_injective k β h | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped ENNReal NNReal Topology BigOperators | |
| namespace MicroscopicJamming | |
| lemma measurable_familyPathWeight {E : Type} [MeasurableSpace E] | |
| (ms : List β) (β : CascadePath ms.length) : Measurable (fun Ο => familyPathWeight (E := E) ms Ο β) := by | |
| induction ms with | |
| | nil => exact measurable_const | |
| | cons m ms ih => | |
| change Measurable (fun Ο : PointCloud (E Γ FamilyCascadeTree E ms.length) => | |
| if β.1.2 < (Ο β.1.1).1 then | |
| ENNReal.ofReal (((β.1.1:β)+((Ο β.1.1).2 β.1.2).1)^(-1/m))* | |
| familyPathWeight ms ((Ο β.1.1).2 β.1.2).2.2 β.2 else 0) | |
| have hi := (ih β.2).comp (by fun_prop : Measurable | |
| (fun Ο : PointCloud (E Γ FamilyCascadeTree E ms.length) => ((Ο β.1.1).2 β.1.2).2.2)) | |
| have hc : MeasurableSet {Ο : PointCloud (E Γ FamilyCascadeTree E ms.length) | | |
| β.1.2 < (Ο β.1.1).1} := measurableSet_lt measurable_const (by fun_prop) | |
| have hw : Measurable (fun Ο : PointCloud (E Γ FamilyCascadeTree E ms.length) => | |
| ENNReal.ofReal (((β.1.1:β)+((Ο β.1.1).2 β.1.2).1)^(-1/m))) := by fun_prop | |
| exact Measurable.ite hc (hw.mul hi) measurable_const | |
| lemma measurable_familyPathMark {E : Type} [MeasurableSpace E] [Add E] [MeasurableAddβ E] | |
| (k : β) (β : CascadePath k) : | |
| Measurable (fun z : E Γ FamilyCascadeTree E k => familyPathMark k z.1 z.2 β) := by | |
| induction k with | |
| | zero => exact measurable_fst | |
| | succ k ih => | |
| exact (ih β.2).comp (show Measurable | |
| (fun z : E Γ PointCloud (E Γ FamilyCascadeTree E k) => | |
| (z.1+((z.2 β.1.1).2 β.1.2).2.1,((z.2 β.1.1).2 β.1.2).2.2)) from by fun_prop) | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped ENNReal NNReal Topology BigOperators | |
| namespace MicroscopicJamming | |
| variable {E : Type} [MeasurableSpace E] [AddMonoid E] [MeasurableAddβ E] | |
| def normalizedFamilyPathWeight (ms : List β) (Ο : FamilyCascadeTree E ms.length) | |
| (β : CascadePath ms.length) : β := | |
| (familyPathWeight ms Ο β/familyUnmarkedTotal ms Ο).toReal | |
| lemma measurable_normalizedFamilyPathWeight (ms : List β) (β : CascadePath ms.length) : | |
| Measurable (fun Ο : FamilyCascadeTree E ms.length => normalizedFamilyPathWeight ms Ο β) := | |
| ((measurable_familyPathWeight ms β).div (measurable_familyUnmarkedTotal ms)).ennreal_toReal | |
| omit [MeasurableAddβ E] in | |
| lemma normalized_familyPath_series [MeasurableAddβ E] (ms : List β) (f : E β ββ₯0β) (x : E) | |
| (Ο : FamilyCascadeTree E ms.length) | |
| (hu : 0 < familyUnmarkedTotal ms Ο) (hf : familyPositiveTotal ms f x Ο β β) : | |
| Summable (fun β => normalizedFamilyPathWeight ms Ο β*(f (familyPathMark ms.length x Ο β)).toReal) β§ | |
| (β' β, normalizedFamilyPathWeight ms Ο β*(f (familyPathMark ms.length x Ο β)).toReal) = | |
| (familyPositiveTotal ms f x Ο/familyUnmarkedTotal ms Ο).toReal := by | |
| let a (β : CascadePath ms.length) : ββ₯0β := | |
| familyPathWeight ms Ο β/familyUnmarkedTotal ms Ο*f (familyPathMark ms.length x Ο β) | |
| have he : (β' β, a β) = familyPositiveTotal ms f x Ο/familyUnmarkedTotal ms Ο := by | |
| simp only [a, div_eq_mul_inv] | |
| simp_rw [mul_right_comm (familyPathWeight ms Ο _) _ (f _)] | |
| rw [ENNReal.tsum_mul_right, tsum_familyPathWeight_terminal] | |
| have ha : (β' β, a β) β β := by rw [he]; exact ENNReal.div_ne_top hf hu.ne' | |
| have hai : β β, a β β β := fun β => ne_top_of_le_ne_top ha (ENNReal.le_tsum β) | |
| have hreal : (fun β => (a β).toReal) = | |
| (fun β => normalizedFamilyPathWeight ms Ο β*(f (familyPathMark ms.length x Ο β)).toReal) := by | |
| funext β | |
| simp only [a, normalizedFamilyPathWeight, ENNReal.toReal_mul] | |
| refine β¨hreal βΈ ENNReal.summable_toReal ha, ?_β© | |
| rw [β hreal, β ENNReal.tsum_toReal_eq hai, he] | |
| lemma normalized_familyPath_weights (ms : List β) (Ο : FamilyCascadeTree E ms.length) | |
| (hu : 0 < familyUnmarkedTotal ms Ο β§ familyUnmarkedTotal ms Ο < β) : | |
| Summable (normalizedFamilyPathWeight ms Ο) β§ (β' β, normalizedFamilyPathWeight ms Ο β) = 1 := by | |
| have hf : familyPositiveTotal ms (fun _ : E => 1) 0 Ο β β := by | |
| simpa only [familyPositiveTotal_const, one_mul] using hu.2.ne | |
| have H := normalized_familyPath_series ms (fun _ : E => 1) 0 Ο hu.1 hf | |
| simpa only [ENNReal.toReal_one, mul_one, familyPositiveTotal_const, one_mul, | |
| ENNReal.div_self hu.1.ne' hu.2.ne] using H | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped ENNReal NNReal Topology BigOperators | |
| namespace MicroscopicJamming | |
| lemma forgetFamilyMarks_zip {E : Type} (k : β) (Ο : CascadeTree k) (y : CascadeMarkTree E k) : | |
| forgetFamilyMarks k (zipCascade k (Ο,y)) = Ο := by | |
| induction k with | |
| | zero => cases Ο; rfl | |
| | succ k ih => | |
| funext n | |
| apply Prod.ext | |
| Β· rfl | |
| Β· funext i | |
| apply Prod.ext | |
| Β· rfl | |
| Β· exact ih _ _ | |
| def normalizedCascadePathWeight (ms : List β) (Ο : CascadeTree ms.length) | |
| (β : CascadePath ms.length) : β := (cascadePathWeight ms Ο β/cascadeTotal ms Ο).toReal | |
| lemma normalizedFamilyPathWeight_zip {E : Type} [MeasurableSpace E] [AddCommMonoid E] | |
| [MeasurableAddβ E] (ms : List β) (Ο : CascadeTree ms.length) | |
| (y : CascadeMarkTree E ms.length) (β : CascadePath ms.length) : | |
| normalizedFamilyPathWeight ms (zipCascade ms.length (Ο,y)) β = | |
| normalizedCascadePathWeight ms Ο β := by | |
| rw [normalizedFamilyPathWeight, familyPathWeight_zip, familyUnmarkedTotal, forgetFamilyMarks_zip] | |
| rfl | |
| def rootMarkCoordinates {E : Type} (k : β) (p : E Γ CascadeMarkTree E k) : | |
| Option (CascadeMarkIndex k) β E := fun i => i.elim p.1 (cascadeMarkCoordinates k p.2) | |
| lemma measurable_rootMarkCoordinates {E : Type} [MeasurableSpace E] (k : β) : | |
| Measurable (rootMarkCoordinates (E := E) k) := by | |
| apply Measurable.of_eval | |
| intro i | |
| cases i with | |
| | none => exact measurable_fst | |
| | some i => exact (measurable_pi_apply i).comp ((measurable_cascadeMarkCoordinates k).comp measurable_snd) | |
| lemma rootMarkCoordinates_law {E : Type} [MeasurableSpace E] (k : β) | |
| (ΞΌ : Measure E) [IsProbabilityMeasure ΞΌ] (Ξ½ : β β Measure E) | |
| [β j, IsProbabilityMeasure (Ξ½ j)] : | |
| (ΞΌ.prod (cascadeMarkLaw k Ξ½)).map (rootMarkCoordinates k) = | |
| Measure.infinitePi (fun i : Option (CascadeMarkIndex k) => i.elim ΞΌ (fun j => Ξ½ (cascadeMarkDepth k j))) := by | |
| rw [show rootMarkCoordinates (E := E) k = (fun z i => i.elim z.1 z.2) β | |
| Prod.map id (cascadeMarkCoordinates k) from rfl, | |
| β Measure.map_map (by | |
| apply Measurable.of_eval | |
| intro i | |
| cases i <;> simp only [Option.elim_none, Option.elim_some] <;> fun_prop) (measurable_id.prodMap (measurable_cascadeMarkCoordinates k)), | |
| β Measure.map_prod_map _ _ measurable_id (measurable_cascadeMarkCoordinates k), Measure.map_id, | |
| cascadeMarkCoordinates_law, infinitePi_option] | |
| def rootPathField {E : Type} [AddCommMonoid E] (k : β) | |
| (g : Option (CascadeMarkIndex k) β E) (β : CascadePath k) : E := | |
| g none+β j : Fin k, g (some (cascadePathIndex k β j)) | |
| lemma rootPathField_eq {E : Type} [AddCommMonoid E] (k : β) (x : E) | |
| (Ο : CascadeTree k) (y : CascadeMarkTree E k) (β : CascadePath k) : | |
| familyPathMark k x (zipCascade k (Ο,y)) β = rootPathField k (rootMarkCoordinates k (x,y)) β := by | |
| rw [familyPathMark_zip] | |
| rfl | |
| def zipRootCascade {E : Type} (k : β) (p : CascadeTree k Γ (E Γ CascadeMarkTree E k)) : | |
| E Γ FamilyCascadeTree E k := (p.2.1, zipCascade k (p.1,p.2.2)) | |
| lemma measurable_zipRootCascade {E : Type} [MeasurableSpace E] (k : β) : | |
| Measurable (zipRootCascade (E := E) k) := | |
| (measurable_fst.comp measurable_snd).prodMk ((measurable_zipCascade k).comp | |
| (measurable_fst.prodMk (measurable_snd.comp measurable_snd))) | |
| lemma zipRootCascade_law {E : Type} [MeasurableSpace E] (ms : List β) | |
| (ΞΌ : Measure E) [IsProbabilityMeasure ΞΌ] (Ξ½ : β β Measure E) | |
| [β j, IsProbabilityMeasure (Ξ½ j)] : | |
| ((cascadeLaw ms).prod (ΞΌ.prod (cascadeMarkLaw ms.length Ξ½))).map (zipRootCascade ms.length) = | |
| ΞΌ.prod (familyCascadeLaw ms.length Ξ½) := by | |
| rw [show zipRootCascade (E := E) ms.length = (Prod.map id (zipCascade ms.length)) β | |
| (fun z => (z.2.1,(z.1,z.2.2))) from rfl, | |
| β Measure.map_map (measurable_id.prodMap (measurable_zipCascade ms.length)) (by fun_prop), | |
| prod_rotate_map, β Measure.map_prod_map _ _ measurable_id (measurable_zipCascade ms.length), | |
| Measure.map_id, cascade_independent_marks] | |
| lemma integral_cascade_coordinates {E : Type} [MeasurableSpace E] [AddCommMonoid E] | |
| [MeasurableAddβ E] (ms : List β) (ΞΌ : Measure E) [IsProbabilityMeasure ΞΌ] | |
| (Ξ½ : β β Measure E) [β j, IsProbabilityMeasure (Ξ½ j)] | |
| {f : E Γ FamilyCascadeTree E ms.length β β} (hf : Measurable f) | |
| {g : CascadeTree ms.length Γ (Option (CascadeMarkIndex ms.length) β E) β β} (hg : Measurable g) | |
| (he : β Ο x y, f (x,zipCascade ms.length (Ο,y)) = g (Ο,rootMarkCoordinates ms.length (x,y))) : | |
| (β« z, f z βΞΌ.prod (familyCascadeLaw ms.length Ξ½)) = | |
| β« z, g z β(cascadeLaw ms).prod (Measure.infinitePi | |
| (fun i : Option (CascadeMarkIndex ms.length) => i.elim ΞΌ (fun j => Ξ½ (cascadeMarkDepth ms.length j)))) := by | |
| rw [β zipRootCascade_law ms ΞΌ Ξ½, | |
| integral_map (measurable_zipRootCascade ms.length).aemeasurable hf.aestronglyMeasurable] | |
| have hmap := rootMarkCoordinates_law ms.length ΞΌ Ξ½ | |
| rw [β hmap, β (Measure.map_id (ΞΌ := cascadeLaw ms)), | |
| Measure.map_prod_map _ _ measurable_id (measurable_rootMarkCoordinates ms.length), | |
| integral_map (measurable_id.prodMap (measurable_rootMarkCoordinates ms.length)).aemeasurable hg.aestronglyMeasurable] | |
| rw [Measure.map_id] | |
| apply integral_congr_ae | |
| exact Eventually.of_forall fun z => he z.1 z.2.1 z.2.2 | |
| end MicroscopicJamming | |
| open MeasureTheory Filter Set | |
| open scoped ENNReal NNReal BigOperators | |
| open Classical | |
| namespace MicroscopicJamming | |
| lemma enn_pair_sum_mul {I : Type*} (a : I β ββ₯0β) : | |
| (β' i, a i)*(β' i, a i) = β' p : I Γ I, a p.1*a p.2 := by | |
| rw [ENNReal.tsum_prod'] | |
| simp_rw [ENNReal.tsum_mul_left] | |
| rw [ENNReal.tsum_mul_right] | |
| lemma enn_pair_same_block {I L : Type*} (a : I β L β ββ₯0β) (R : L β L β Prop) : | |
| (β' p : (I Γ L) Γ (I Γ L), | |
| if p.1.1=p.2.1 β§ R p.1.2 p.2.2 then a p.1.1 p.1.2*a p.2.1 p.2.2 else 0) = | |
| β' i, β' p : L Γ L, if R p.1 p.2 then a i p.1*a i p.2 else 0 := by | |
| rw [ENNReal.tsum_prod'] | |
| simp_rw [ENNReal.tsum_prod'] | |
| apply tsum_congr | |
| intro i | |
| rw [ENNReal.tsum_comm] | |
| have H (j : I) : (β' l, β' r, if i=j β§ R l r then a i l*a j r else 0) = | |
| if i=j then β' l, β' r, if R l r then a i l*a j r else 0 else 0 := by | |
| by_cases h : i=j <;> simp [h] | |
| simp_rw [H] | |
| simpa only [eq_comm] using (tsum_ite_eq i (fun j => β' l, β' r, if R l r then a i l*a j r else 0)) | |
| lemma enn_pair_scale {L : Type*} (a : L β ββ₯0β) (c : ββ₯0β) (R : L β L β Prop) : | |
| (β' p : L Γ L, if R p.1 p.2 then (c*a p.1)*(c*a p.2) else 0) = | |
| c^2*(β' p : L Γ L, if R p.1 p.2 then a p.1*a p.2 else 0) := by | |
| rw [β ENNReal.tsum_mul_left] | |
| apply tsum_congr | |
| intro p | |
| split_ifs | |
| Β· ring | |
| Β· simp only [mul_zero] | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped ENNReal NNReal BigOperators | |
| open Classical | |
| namespace MicroscopicJamming | |
| def pathAgree : (k : β) β β β CascadePath k β CascadePath k β Prop | |
| | 0, _, _, _ => True | |
| | _+1, 0, _, _ => True | |
| | k+1, j+1, a, b => a.1=b.1 β§ pathAgree k j a.2 b.2 | |
| def familyLeafMass {E : Type} [Add E] (ms : List β) (u : E β β) (x : E) | |
| (Ο : FamilyCascadeTree E ms.length) (β : CascadePath ms.length) : ββ₯0β := | |
| familyPathWeight ms Ο β*ENNReal.ofReal (Real.exp (u (familyPathMark ms.length x Ο β))) | |
| def familyPairSum {E : Type} [Add E] (ms : List β) (j : β) (u : E β β) (x : E) | |
| (Ο : FamilyCascadeTree E ms.length) : ββ₯0β := | |
| β' p : CascadePath ms.length Γ CascadePath ms.length, | |
| if pathAgree ms.length j p.1 p.2 then familyLeafMass ms u x Ο p.1*familyLeafMass ms u x Ο p.2 else 0 | |
| lemma tsum_familyLeafMass {E : Type} [MeasurableSpace E] [Add E] [MeasurableAddβ E] | |
| (ms : List β) (u : E β β) (x : E) (Ο : FamilyCascadeTree E ms.length) : | |
| (β' β, familyLeafMass ms u x Ο β) = familyLeafTotal ms u x Ο := by | |
| exact (tsum_familyPathWeight_terminal ms (fun y => ENNReal.ofReal (Real.exp (u y))) x Ο).trans | |
| (familyPositiveTotal_exp ms u x Ο) | |
| lemma pathAgree_zero (k : β) (a b : CascadePath k) : pathAgree k 0 a b := by | |
| cases k <;> trivial | |
| lemma familyPairSum_zero {E : Type} [MeasurableSpace E] [Add E] [MeasurableAddβ E] | |
| (ms : List β) (u : E β β) (x : E) (Ο : FamilyCascadeTree E ms.length) : | |
| familyPairSum ms 0 u x Ο = (familyLeafTotal ms u x Ο)^2 := by | |
| simp only [familyPairSum, pathAgree_zero, ite_true] | |
| rw [β enn_pair_sum_mul, tsum_familyLeafMass, pow_two] | |
| lemma familyLeafMass_cons {E : Type} [Add E] (m : β) (ms : List β) | |
| (u : E β β) (x : E) (Ο : FamilyCascadeTree E (m::ms).length) | |
| (i : β Γ β) (β : CascadePath ms.length) : | |
| familyLeafMass (m::ms) u x Ο (i,β) = | |
| (if i.2 < (Ο i.1).1 then ENNReal.ofReal (((i.1:β)+((Ο i.1).2 i.2).1)^(-1/m)) else 0)* | |
| familyLeafMass ms u (x+((Ο i.1).2 i.2).2.1) ((Ο i.1).2 i.2).2.2 β := by | |
| by_cases hi : i.2 < (Ο i.1).1 | |
| Β· simp only [familyLeafMass, List.length_cons, familyPathWeight, familyPathMark, hi, ite_true, mul_assoc] | |
| Β· simp only [familyLeafMass, familyPathWeight, hi, ite_false, zero_mul] | |
| lemma familyPairSum_cons {E : Type} [MeasurableSpace E] [Add E] [MeasurableAddβ E] | |
| (m : β) (ms : List β) (j : β) (u : E β β) (x : E) | |
| (Ο : FamilyCascadeTree E (m::ms).length) : | |
| familyPairSum (m::ms) (j+1) u x Ο = | |
| pointCloudFunctional (fun z : β Γ (E Γ FamilyCascadeTree E ms.length) => | |
| (ENNReal.ofReal (z.1^(-1/m)))^2*familyPairSum ms j u (x+z.2.1) z.2.2) Ο := by | |
| simp only [familyPairSum, List.length_cons, pathAgree] | |
| change (β' p : ((β Γ β) Γ CascadePath ms.length) Γ ((β Γ β) Γ CascadePath ms.length), | |
| if p.1.1=p.2.1 β§ pathAgree ms.length j p.1.2 p.2.2 then | |
| familyLeafMass (m::ms) u x Ο p.1*familyLeafMass (m::ms) u x Ο p.2 else 0) = _ | |
| refine Eq.trans ?_ ((enn_pair_same_block (fun i β => familyLeafMass (m::ms) u x Ο (i,β)) | |
| (pathAgree ms.length j)).trans ?_) | |
| Β· apply tsum_congr | |
| rintro β¨β¨i,ββ©,β¨j,rβ©β© | |
| split_ifs <;> rfl | |
| Β· simp_rw [familyLeafMass_cons, enn_pair_scale] | |
| rw [ENNReal.tsum_prod'] | |
| simp only [pointCloudFunctional, poissonBinSum] | |
| apply tsum_congr | |
| intro n | |
| rw [tsum_eq_sum (s := Finset.range (Ο n).1) (fun i hi => by | |
| simp only [Finset.mem_range, not_lt] at hi | |
| simp [not_lt.mpr hi])] | |
| apply Finset.sum_congr rfl | |
| intro i hi | |
| simp only [Finset.mem_range.mp hi, ite_true] | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped ENNReal NNReal BigOperators | |
| open Classical | |
| namespace MicroscopicJamming | |
| lemma cascadePathIndex_eq_iff (k : β) (a b : CascadePath k) (j : Fin k) : | |
| cascadePathIndex k a j = cascadePathIndex k b j β pathAgree k (j.val+1) a b := by | |
| induction k with | |
| | zero => exact Fin.elim0 j | |
| | succ k ih => | |
| refine Fin.cases ?_ (fun i => ?_) j | |
| Β· change (a.1.1,a.1.2,none) = (b.1.1,b.1.2,(none : Option (CascadeMarkIndex k))) β | |
| a.1=b.1 β§ pathAgree k 0 a.2 b.2 | |
| simp [Prod.ext_iff, pathAgree_zero] | |
| Β· change (a.1.1,a.1.2,some (cascadePathIndex k a.2 i)) = | |
| (b.1.1,b.1.2,some (cascadePathIndex k b.2 i)) β | |
| a.1=b.1 β§ pathAgree k (i.val+1) a.2 b.2 | |
| simp only [Option.some.injEq, ih, Prod.ext_iff] | |
| tauto | |
| lemma cascadePathIndex_depth_eq {k : β} {a b : CascadePath k} {i j : Fin k} | |
| (h : cascadePathIndex k a i = cascadePathIndex k b j) : i = j := by | |
| apply Fin.ext | |
| simpa only [cascadePathIndex_depth] using congrArg (cascadeMarkDepth k) h | |
| def rootPathIndex (k : β) (β : CascadePath k) : Fin (k+1) β Option (CascadeMarkIndex k) := | |
| Fin.cases none (fun j => some (cascadePathIndex k β j)) | |
| lemma rootPathIndex_injective (k : β) (β : CascadePath k) : | |
| Function.Injective (rootPathIndex k β) := by | |
| intro i j h | |
| cases i using Fin.cases with | |
| | zero => | |
| cases j using Fin.cases with | |
| | zero => rfl | |
| | succ j => simp [rootPathIndex] at h | |
| | succ i => | |
| cases j using Fin.cases with | |
| | zero => simp [rootPathIndex] at h | |
| | succ j => | |
| apply congrArg Fin.succ | |
| exact cascadePathIndex_injective k β (Option.some.inj h) | |
| lemma rootPathIndex_depth_eq {k : β} {a b : CascadePath k} {i j : Fin (k+1)} | |
| (h : rootPathIndex k a i = rootPathIndex k b j) : i = j := by | |
| cases i using Fin.cases with | |
| | zero => | |
| cases j using Fin.cases with | |
| | zero => rfl | |
| | succ j => simp [rootPathIndex] at h | |
| | succ i => | |
| cases j using Fin.cases with | |
| | zero => simp [rootPathIndex] at h | |
| | succ j => exact congrArg Fin.succ (cascadePathIndex_depth_eq (Option.some.inj h)) | |
| lemma rootPathIndex_eq_iff (k : β) (a b : CascadePath k) (j : Fin (k+1)) : | |
| rootPathIndex k a j = rootPathIndex k b j β pathAgree k j.val a b := by | |
| cases j using Fin.cases with | |
| | zero => simp [rootPathIndex, pathAgree_zero] | |
| | succ j => simpa only [rootPathIndex, Fin.cases_succ, Option.some.injEq, Fin.val_succ] | |
| using cascadePathIndex_eq_iff k a b j | |
| lemma finite_incidence_covariance {A J : Type*} [Fintype A] [Fintype J] | |
| (e f : J β A) (_hf : Function.Injective f) (v : J β β) | |
| (hdepth : β i j, e i = f j β i = j) : | |
| (β a : A, (β i : J, if e i=a then v i else 0)*(β j : J, if f j=a then v j else 0)) = | |
| β i : J, if e i=f i then (v i)^2 else 0 := by | |
| simp_rw [Finset.sum_mul, Finset.mul_sum] | |
| rw [Finset.sum_comm] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [Finset.sum_comm] | |
| have he (j : J) : (β a : A, (if e i=a then v i else 0)*(if f j=a then v j else 0)) = | |
| if e i=f j then v i*v j else 0 := by | |
| rw [Finset.sum_eq_single (e i)] | |
| Β· simp only [ite_true] | |
| by_cases hh : e i=f j | |
| Β· simp [hh] | |
| Β· simp [hh, Ne.symm hh] | |
| Β· intro a _ ha | |
| simp [Ne.symm ha] | |
| Β· simp | |
| simp_rw [he] | |
| rw [Finset.sum_eq_single i] | |
| Β· simp [pow_two] | |
| Β· intro j _ hj | |
| simp only [ite_eq_right (fun hh => hj (hdepth i j hh).symm)] | |
| Β· simp | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped ENNReal NNReal Topology BigOperators | |
| open Classical | |
| namespace MicroscopicJamming | |
| def cascadeCoordinateSet (k : β) (S : Finset (CascadePath k)) : Finset (Option (CascadeMarkIndex k)) := | |
| S.biUnion (fun β => Finset.univ.image (rootPathIndex k β)) | |
| lemma rootPathIndex_mem (k : β) (S : Finset (CascadePath k)) (β : S) (j : Fin (k+1)) : | |
| rootPathIndex k β.val j β cascadeCoordinateSet k S := by | |
| apply Finset.mem_biUnion.mpr | |
| exact β¨β.val,β.property,Finset.mem_image.mpr β¨j,Finset.mem_univ j,rflβ©β© | |
| def finiteRootPathIndex (k : β) (S : Finset (CascadePath k)) (β : S) (j : Fin (k+1)) : | |
| cascadeCoordinateSet k S := β¨rootPathIndex k β.val j,rootPathIndex_mem k S β jβ© | |
| def finiteRootPathField {E : Type} [AddCommMonoid E] (k : β) (S : Finset (CascadePath k)) | |
| (z : cascadeCoordinateSet k S β E) (β : S) : E := β j, z (finiteRootPathIndex k S β j) | |
| lemma rootPathField_finite {E : Type} [AddCommMonoid E] (k : β) (S : Finset (CascadePath k)) | |
| (z : Option (CascadeMarkIndex k) β E) (β : S) : | |
| rootPathField k z β.val = finiteRootPathField k S ((cascadeCoordinateSet k S).restrict z) β := by | |
| rw [finiteRootPathField, Fin.sum_univ_succ] | |
| rfl | |
| lemma measurable_finiteRootPathField {E : Type} [MeasurableSpace E] [AddCommMonoid E] | |
| [MeasurableAddβ E] (k : β) (S : Finset (CascadePath k)) : | |
| Measurable (fun z β => finiteRootPathField (E := E) k S z β) := by | |
| unfold finiteRootPathField | |
| fun_prop | |
| lemma integral_cascade_finite_coordinates {E : Type} [MeasurableSpace E] [AddCommMonoid E] | |
| [MeasurableAddβ E] (ms : List β) (S : Finset (CascadePath ms.length)) | |
| (ΞΌ : Measure E) [IsProbabilityMeasure ΞΌ] (Ξ½ : β β Measure E) | |
| [β j, IsProbabilityMeasure (Ξ½ j)] | |
| {f : E Γ FamilyCascadeTree E ms.length β β} (hf : Measurable f) | |
| {g : CascadeTree ms.length Γ (cascadeCoordinateSet ms.length S β E) β β} (hg : Measurable g) | |
| (he : β Ο x y, f (x,zipCascade ms.length (Ο,y)) = | |
| g (Ο,(cascadeCoordinateSet ms.length S).restrict (rootMarkCoordinates ms.length (x,y)))) : | |
| (β« z, f z βΞΌ.prod (familyCascadeLaw ms.length Ξ½)) = | |
| β« z, g z β(cascadeLaw ms).prod (Measure.pi | |
| (fun i : cascadeCoordinateSet ms.length S => i.val.elim ΞΌ (fun j => Ξ½ (cascadeMarkDepth ms.length j)))) := by | |
| let C := cascadeCoordinateSet ms.length S | |
| let Ξ· : Option (CascadeMarkIndex ms.length) β Measure E := | |
| fun i => i.elim ΞΌ (fun j => Ξ½ (cascadeMarkDepth ms.length j)) | |
| have hΞ· (i) : IsProbabilityMeasure (Ξ· i) := by cases i <;> dsimp [Ξ·] <;> infer_instance | |
| let := hΞ· | |
| have hm : Measurable (Prod.map (id : CascadeTree ms.length β CascadeTree ms.length) | |
| (C.restrict : (Option (CascadeMarkIndex ms.length) β E) β (C β E))) := by | |
| exact measurable_id.prodMap (Measurable.of_eval fun i => measurable_pi_apply i.val) | |
| rw [integral_cascade_coordinates ms ΞΌ Ξ½ hf (hg.comp hm) he] | |
| have hr : Measurable (C.restrict : (Option (CascadeMarkIndex ms.length) β E) β (C β E)) := | |
| Measurable.of_eval fun i => measurable_pi_apply i.val | |
| change (β« z, g (Prod.map id C.restrict z) β(cascadeLaw ms).prod (Measure.infinitePi Ξ·)) = _ | |
| rw [β integral_map hm.aemeasurable hg.aestronglyMeasurable, | |
| β Measure.map_prod_map _ _ measurable_id hr, Measure.map_id, Measure.infinitePi_map_restrict] | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped ENNReal NNReal Topology BigOperators | |
| open Classical | |
| namespace MicroscopicJamming | |
| lemma weighted_incidence_covariance {A J : Type*} [Fintype A] [Fintype J] | |
| (e f : J β A) (q : A β β) (hdepth : β i j, e i=f j β i=j) : | |
| (β a : A, q a*(β i : J, if e i=a then (1:β) else 0)*(β j : J, if f j=a then (1:β) else 0)) = | |
| β i : J, if e i=f i then q (e i) else 0 := by | |
| calc | |
| _ = β i : J, β a : A, (q a*(if e i=a then (1:β) else 0))* | |
| (β j : J, if f j=a then (1:β) else 0) := by | |
| rw [Finset.sum_comm] | |
| apply Finset.sum_congr rfl | |
| intro a _ | |
| rw [β Finset.sum_mul, β Finset.mul_sum] | |
| _ = β i : J, q (e i)*(β j : J, if f j=e i then (1:β) else 0) := by | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [Finset.sum_eq_single (e i)] | |
| Β· simp | |
| Β· intro a _ ha | |
| simp [Ne.symm ha] | |
| Β· simp | |
| _ = _ := by | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [Finset.sum_eq_single i] | |
| Β· by_cases hh : e i=f i <;> simp [hh, Ne.symm] | |
| Β· intro j _ hj | |
| exact ite_eq_right (fun hh => hj (hdepth i j hh.symm).symm) | |
| Β· simp | |
| def rootCoordinateVariance (k : β) (d : β β ββ₯0) (pβ : ββ₯0) | |
| (a : Option (CascadeMarkIndex k)) : ββ₯0 := | |
| a.elim pβ (fun j => d (cascadeMarkDepth k j)) | |
| def pathCovarianceDifference (k : β) (d d' : β β ββ₯0) (pβ pβ' : ββ₯0) | |
| (a b : CascadePath k) : β := | |
| (pβ:β)-(pβ':β)+β j : Fin k, | |
| if pathAgree k (j.val+1) a b then (d j:β)-(d' j:β) else 0 | |
| lemma rootVariance_path (k : β) (d : β β ββ₯0) (pβ : ββ₯0) | |
| (β : CascadePath k) (j : Fin (k+1)) : | |
| rootCoordinateVariance k d pβ (rootPathIndex k β j) = Fin.cases pβ (fun i => d i) j := by | |
| cases j using Fin.cases with | |
| | zero => rfl | |
| | succ j => change d (cascadeMarkDepth k (cascadePathIndex k β j)) = d j | |
| rw [cascadePathIndex_depth] | |
| lemma finiteRoot_incidence_covariance (k : β) (S : Finset (CascadePath k)) | |
| (d d' : β β ββ₯0) (pβ pβ' : ββ₯0) (β r : S) : | |
| (β a : cascadeCoordinateSet k S, | |
| ((rootCoordinateVariance k d pβ a:β)-(rootCoordinateVariance k d' pβ' a:β))* | |
| (β j : Fin (k+1), if finiteRootPathIndex k S β j=a then (1:β) else 0)* | |
| (β j : Fin (k+1), if finiteRootPathIndex k S r j=a then (1:β) else 0)) = | |
| pathCovarianceDifference k d d' pβ pβ' β.val r.val := by | |
| have H := weighted_incidence_covariance (finiteRootPathIndex k S β) | |
| (finiteRootPathIndex k S r) | |
| (fun a => (rootCoordinateVariance k d pβ a:β)-(rootCoordinateVariance k d' pβ' a:β)) | |
| (fun i j hij => rootPathIndex_depth_eq (congrArg Subtype.val hij)) | |
| calc | |
| _ = β i : Fin (k+1), if finiteRootPathIndex k S β i=finiteRootPathIndex k S r i then | |
| (rootCoordinateVariance k d pβ (finiteRootPathIndex k S β i):β)- | |
| (rootCoordinateVariance k d' pβ' (finiteRootPathIndex k S β i):β) else 0 := by | |
| convert H using 1 <;> congr 4 <;> funext a <;> congr 3 <;> funext j <;> split_ifs <;> rfl | |
| _ = _ := by | |
| rw [Fin.sum_univ_succ] | |
| simp only [finiteRootPathIndex, Subtype.mk.injEq, rootPathIndex_eq_iff, | |
| rootVariance_path, Fin.cases_zero, Fin.cases_succ, Fin.val_zero, Fin.val_succ, | |
| pathAgree_zero, ite_true, pathCovarianceDifference] | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Set | |
| open scoped ENNReal NNReal BigOperators | |
| open Classical | |
| namespace MicroscopicJamming | |
| def rowReplicaCovariance (k r : β) (d : β β ββ₯0) (pβ : ββ₯0) | |
| (xs : Fin r β CascadePath k) : Matrix (Fin r) (Fin r) β := | |
| fun i j => (pβ:β) + β a : Fin k, if pathAgree k (a.val+1) (xs i) (xs j) then (d a:β) else 0 | |
| def rowReplicaGaussianField (k r : β) (xs : Fin r β CascadePath k) | |
| (z : Option (CascadeMarkIndex k) β β) : EuclideanSpace β (Fin r) := | |
| WithLp.toLp 2 (fun i => rootPathField k z (xs i)) | |
| def RowReplicaGaussianStatement : Prop := | |
| β (k r : β) (d : β β ββ₯0) (pβ : ββ₯0) (xs : Fin r β CascadePath k), | |
| (rowReplicaCovariance k r d pβ xs).PosSemidef β§ | |
| (Measure.infinitePi (fun a => gaussianReal 0 (rootCoordinateVariance k d pβ a))).map | |
| (rowReplicaGaussianField k r xs) = multivariateGaussian 0 (rowReplicaCovariance k r d pβ xs) | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Set | |
| open scoped ENNReal NNReal BigOperators | |
| open Classical | |
| namespace MicroscopicJamming | |
| def rowReplicaResidualCovariance (k r : β) (d : β β ββ₯0) (pβ Ξ : ββ₯0) | |
| (xs : Fin r β CascadePath k) : Matrix (Fin r) (Fin r) β := | |
| rowReplicaCovariance k r d pβ xs + Matrix.diagonal (fun _ => (Ξ:β)) | |
| def rowReplicaResidualField (k r : β) (xs : Fin r β CascadePath k) | |
| (w : (Option (CascadeMarkIndex k) β β) Γ (Fin r β β)) : EuclideanSpace β (Fin r) := | |
| rowReplicaGaussianField k r xs w.1 + WithLp.toLp 2 w.2 | |
| def RowReplicaResidualStatement : Prop := | |
| β (k r : β) (d : β β ββ₯0) (pβ Ξ : ββ₯0) (xs : Fin r β CascadePath k), | |
| (rowReplicaResidualCovariance k r d pβ Ξ xs).PosSemidef β§ | |
| ((Measure.infinitePi (fun a => gaussianReal 0 (rootCoordinateVariance k d pβ a))).prod | |
| (Measure.pi (fun _ : Fin r => gaussianReal 0 Ξ))).map | |
| (rowReplicaResidualField k r xs) = | |
| multivariateGaussian 0 (rowReplicaResidualCovariance k r d pβ Ξ xs) | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped ENNReal NNReal Topology BigOperators MatrixOrder | |
| namespace MicroscopicJamming | |
| def gaussianAdjunctionMap {A : Type*} (m : β) | |
| (C : A β Matrix (Fin m) (Fin m) β) | |
| (w : A Γ EuclideanSpace β (Fin m)) : A Γ EuclideanSpace β (Fin m) := | |
| (w.1, Matrix.toEuclideanCLM (π := β) (CFC.sqrt (C w.1)) w.2) | |
| def gaussianAdjunctionMeasure {A : Type*} [MeasurableSpace A] (m : β) | |
| (C : A β Matrix (Fin m) (Fin m) β) (ΞΌ : Measure A) : | |
| Measure (A Γ EuclideanSpace β (Fin m)) := | |
| (ΞΌ.prod (stdGaussian (EuclideanSpace β (Fin m)))).map (gaussianAdjunctionMap m C) | |
| def GaussianAdjunctionStatement : Prop := | |
| β (A : Type) (tA : TopologicalSpace A) (mA : MeasurableSpace A), | |
| β (_hB : @BorelSpace A tA mA) (_hSC : SecondCountableTopology A) | |
| (_hPM : TopologicalSpace.PseudoMetrizableSpace A), | |
| β (m : β) (C : A β Matrix (Fin m) (Fin m) β), | |
| Continuous C β (β x, (C x).PosSemidef) β | |
| (β K : β, β x i j, |C x i j| β€ K) β | |
| β (ΞΌ : β β ProbabilityMeasure A) (ΞΌβ : ProbabilityMeasure A), | |
| Tendsto ΞΌ atTop (π ΞΌβ) β | |
| β (Ο : β β ProbabilityMeasure (A Γ EuclideanSpace β (Fin m))) | |
| (Οβ : ProbabilityMeasure (A Γ EuclideanSpace β (Fin m))), | |
| (β n, (Ο n : Measure _) = gaussianAdjunctionMeasure m C (ΞΌ n)) β§ | |
| (Οβ : Measure _) = gaussianAdjunctionMeasure m C ΞΌβ β§ | |
| Tendsto Ο atTop (π Οβ) | |
| end MicroscopicJamming | |
| end | |
| end OAI | |