| import Mathlib |
| import OAI.MeasureTheory.FalconerCompletion.Measures.PathIndex2 |
|
|
| namespace OAI |
|
|
| /-! Dyadic shells and prefix decompositions. -/ |
|
|
| section |
| section |
| open Set MeasureTheory |
| open scoped ComplexConjugate RealInnerProductSpace |
| namespace GraphLiteralSupport |
| namespace CurrentFalconer.TreeND |
| open Set MeasureTheory |
| open scoped ENNReal |
| variable {d : ℕ} |
| noncomputable def leafUnion (L : Finset ((CellPath d))) : Set (EuclideanSpace ℝ (Fin d)) := |
| ⋃ p ∈ L, (treeCell p) |
|
|
| theorem leafUnion_measurable (L : Finset ((CellPath d))) : |
| MeasurableSet (leafUnion L) := |
| Finset.measurableSet_biUnion _ (fun p _ => (measurableSet_treeCell p)) |
|
|
| theorem leafUnion_mono {L T : Finset ((CellPath d))} |
| (h : L ⊆ T) : leafUnion L ⊆ leafUnion T := by |
| intro z hz |
| obtain ⟨p,hp,hz⟩ := mem_iUnion₂.mp hz |
| exact mem_iUnion₂.mpr ⟨p,h hp,hz⟩ |
|
|
| theorem leafUnion_disjoint {N : ℕ} |
| {L T : Finset ((CellPath d))} (hL : L ⊆ dyadicPaths N) |
| (hT : T ⊆ dyadicPaths N) (h : Disjoint L T) : |
| Disjoint (leafUnion L) (leafUnion T) := by |
| apply Set.disjoint_left.mpr |
| intro z hz hz' |
| obtain ⟨p,hp,hzp⟩ := mem_iUnion₂.mp hz |
| obtain ⟨q,hq,hzq⟩ := mem_iUnion₂.mp hz' |
| have hne : p ≠ q := by |
| intro he; subst q; exact Finset.disjoint_left.mp h hp hq |
| exact Set.disjoint_left.mp (treeCell_disjoint |
| ((mem_dyadicPaths _ _).mp (hL hp) |>.trans ((mem_dyadicPaths _ _).mp (hT hq)).symm) |
| hne) hzp hzq |
|
|
| theorem measure_leafUnion (μ : Measure (EuclideanSpace ℝ (Fin d))) |
| {N : ℕ} {L : Finset ((CellPath d))} (hL : L ⊆ dyadicPaths N) : |
| μ (leafUnion L) = ∑ p ∈ L, μ (treeCell p) := by |
| apply measure_biUnion_finset |
| · intro p hp q hq hne |
| exact treeCell_disjoint |
| (((mem_dyadicPaths _ _).mp (hL hp)).trans ((mem_dyadicPaths _ _).mp (hL hq)).symm) |
| hne |
| · intro p _; exact (measurableSet_treeCell p) |
|
|
| noncomputable def retainedLeaves (μ : Measure (EuclideanSpace ℝ (Fin d))) (N : ℕ) |
| (t : ℝ≥0∞) : Finset ((CellPath d)) := by |
| classical |
| exact (dyadicPaths N).filter fun p => t ≤ μ (treeCell p) |
|
|
| theorem discarded_leaves_mass (μ : Measure (EuclideanSpace ℝ (Fin d))) (N : ℕ) (t : ℝ≥0∞) : |
| μ (leafUnion (dyadicPaths N \ retainedLeaves μ N t)) ≤ (2 : ℝ≥0∞)^(d*N) * t := by |
| classical |
| rw [measure_leafUnion μ Finset.sdiff_subset] |
| calc |
| _ ≤ ∑ _p ∈ dyadicPaths N \ retainedLeaves μ N t, t := by |
| apply Finset.sum_le_sum |
| intro p hp |
| have hp' := Finset.mem_sdiff.mp hp |
| have : ¬ t ≤ μ (treeCell p) := by |
| intro ht |
| exact hp'.2 (Finset.mem_filter.mpr ⟨hp'.1,ht⟩) |
| exact (lt_of_not_ge this).le |
| _ ≤ (2 : ℝ≥0∞)^(d*N) * t := by |
| simp only [Finset.sum_const, nsmul_eq_mul] |
| apply mul_le_mul_left |
| exact_mod_cast (Finset.card_le_card Finset.sdiff_subset).trans (by simpa only [← pow_mul,Nat.mul_comm] using dyadicPaths_card_le (d := d) N) |
|
|
| noncomputable def classMeasure (μ : Measure (EuclideanSpace ℝ (Fin d))) |
| (L : Finset ((CellPath d))) (f : (CellPath d) → List ℕ) (T : List ℕ) : |
| Measure (EuclideanSpace ℝ (Fin d)) := μ.restrict (leafUnion (classLeaves L f T)) |
|
|
| theorem classLeaves_disjoint (L : Finset ((CellPath d))) |
| (f : (CellPath d) → List ℕ) {T U : List ℕ} (h : T ≠ U) : |
| Disjoint (classLeaves L f T) (classLeaves L f U) := by |
| classical |
| apply Finset.disjoint_left.mpr |
| intro p hp hq |
| exact h ((Finset.mem_filter.mp hp).2.symm.trans (Finset.mem_filter.mp hq).2) |
|
|
| theorem leafUnion_classes (L : Finset ((CellPath d))) |
| (f : (CellPath d) → List ℕ) : |
| (⋃ T ∈ L.image f, leafUnion (classLeaves L f T)) = leafUnion L := by |
| classical |
| ext z |
| constructor |
| · intro hz |
| obtain ⟨T,_,hz⟩ := mem_iUnion₂.mp hz |
| obtain ⟨p,hp,hz⟩ := mem_iUnion₂.mp hz |
| exact mem_iUnion₂.mpr ⟨p,(Finset.mem_filter.mp hp).1,hz⟩ |
| · intro hz |
| obtain ⟨p,hp,hz⟩ := mem_iUnion₂.mp hz |
| exact mem_iUnion₂.mpr ⟨f p,Finset.mem_image.mpr ⟨p,hp,rfl⟩, |
| mem_iUnion₂.mpr ⟨p,by simp [classLeaves,hp],hz⟩⟩ |
|
|
| theorem class_mass_sum (μ : Measure (EuclideanSpace ℝ (Fin d))) |
| {N : ℕ} {L : Finset ((CellPath d))} (hL : L ⊆ dyadicPaths N) |
| (f : (CellPath d) → List ℕ) : |
| (∑ T ∈ L.image f, classMeasure μ L f T univ) = μ (leafUnion L) := by |
| classical |
| simp only [classMeasure, Measure.restrict_apply_univ] |
| rw [← leafUnion_classes L f] |
| symm |
| apply measure_biUnion_finset |
| · intro T _ U _ hne |
| exact leafUnion_disjoint (fun _ hp => hL (Finset.mem_filter.mp hp).1) |
| (fun _ hp => hL (Finset.mem_filter.mp hp).1) (classLeaves_disjoint L f hne) |
| · intro T _; exact leafUnion_measurable _ |
|
|
| theorem discarded_classes_mass (μ : Measure (EuclideanSpace ℝ (Fin d))) |
| (L : Finset ((CellPath d))) (f : (CellPath d) → List ℕ) |
| (t : ℝ≥0∞) : |
| μ (⋃ T ∈ (L.image f).filter (fun T => classMeasure μ L f T univ < t), |
| leafUnion (classLeaves L f T)) ≤ ((L.image f).card : ℝ≥0∞) * t := by |
| classical |
| calc |
| _ ≤ ∑ T ∈ (L.image f).filter (fun T => classMeasure μ L f T univ < t), |
| μ (leafUnion (classLeaves L f T)) := measure_biUnion_finset_le _ _ |
| _ ≤ ∑ _T ∈ (L.image f).filter (fun T => classMeasure μ L f T univ < t), t := by |
| apply Finset.sum_le_sum |
| intro T hT |
| simpa only [classMeasure, Measure.restrict_apply_univ] using (Finset.mem_filter.mp hT).2.le |
| _ ≤ _ := by |
| simp only [Finset.sum_const, nsmul_eq_mul] |
| apply mul_le_mul_left |
| exact_mod_cast (Finset.card_filter_le (s := L.image f) |
| (fun T => classMeasure μ L f T univ < t)) |
|
|
| noncomputable def normalizedClass (μ : Measure (EuclideanSpace ℝ (Fin d))) |
| (L : Finset ((CellPath d))) (f : (CellPath d) → List ℕ) (T : List ℕ) : |
| Measure (EuclideanSpace ℝ (Fin d)) := (classMeasure μ L f T univ)⁻¹ • classMeasure μ L f T |
|
|
| theorem normalizedClass_probability (μ : Measure (EuclideanSpace ℝ (Fin d))) |
| [IsFiniteMeasure μ] (L : Finset ((CellPath d))) |
| (f : (CellPath d) → List ℕ) (T : List ℕ) |
| (h : classMeasure μ L f T univ ≠ 0) : |
| IsProbabilityMeasure (normalizedClass μ L f T) := by |
| constructor |
| simp only [normalizedClass, Measure.smul_apply, smul_eq_mul] |
| apply ENNReal.inv_mul_cancel h |
| simp only [classMeasure, Measure.restrict_apply_univ] |
| exact measure_ne_top _ _ |
|
|
| theorem normalizedClass_apply (μ : Measure (EuclideanSpace ℝ (Fin d))) |
| (L : Finset ((CellPath d))) (f : (CellPath d) → List ℕ) (T : List ℕ) |
| (S : Set (EuclideanSpace ℝ (Fin d))) : |
| normalizedClass μ L f T S = |
| (μ (leafUnion (classLeaves L f T)))⁻¹ * |
| μ (S ∩ leafUnion (classLeaves L f T)) := by |
| simp only [normalizedClass, classMeasure, |
| Measure.smul_apply, smul_eq_mul, |
| Measure.restrict_apply' (leafUnion_measurable _), univ_inter] |
|
|
| theorem leafUnion_inter_prefix {N a : ℕ} (ha : a ≤ N) {C : Finset (CellPath d)} (hC : C ⊆ dyadicPaths N) |
| {P : (CellPath d)} (hP : P.length = a) : |
| (treeCell P) ∩ leafUnion C = leafUnion (prefixFiber C a P) := by |
| classical |
| ext z |
| constructor |
| · rintro ⟨hzP,hzC⟩ |
| obtain ⟨q,hq,hzq⟩ := mem_iUnion₂.mp hzC |
| have hqN := (mem_dyadicPaths _ _).mp (hC hq) |
| have hlen : (q.take a).length = P.length := by simp [List.length_take,hqN,ha,hP] |
| have he : q.take a = P := by |
| by_contra hne |
| exact Set.disjoint_left.mp (treeCell_disjoint hlen hne) |
| (treeCell_subset_take q a hzq) hzP |
| exact mem_iUnion₂.mpr ⟨q,by simp [prefixFiber,hq,he],hzq⟩ |
| · intro hz |
| obtain ⟨q,hq,hzq⟩ := mem_iUnion₂.mp hz |
| obtain ⟨hq,he⟩ := Finset.mem_filter.mp hq |
| refine ⟨?_,mem_iUnion₂.mpr ⟨q,hq,hzq⟩⟩ |
| rw [← he] |
| exact treeCell_subset_take q a hzq |
|
|
| theorem restriction_prefix_mass (μ : Measure (EuclideanSpace ℝ (Fin d))) |
| {N a : ℕ} (ha : a ≤ N) {C : Finset (CellPath d)} (hC : C ⊆ dyadicPaths N) |
| {P : (CellPath d)} (hP : P.length = a) : |
| (μ.restrict (leafUnion C)) (treeCell P) = |
| ∑ q ∈ prefixFiber C a P, μ (treeCell q) := by |
| rw [Measure.restrict_apply (measurableSet_treeCell P), |
| leafUnion_inter_prefix ha hC hP] |
| exact measure_leafUnion μ (fun q hq => hC (Finset.mem_filter.mp hq).1) |
|
|
| theorem restriction_prefix_mass_real (μ : Measure (EuclideanSpace ℝ (Fin d))) [IsFiniteMeasure μ] |
| {N a : ℕ} (ha : a ≤ N) {C : Finset (CellPath d)} (hC : C ⊆ dyadicPaths N) |
| {P : (CellPath d)} (hP : P.length = a) : |
| ((μ.restrict (leafUnion C)) (treeCell P)).toReal = |
| ∑ q ∈ prefixFiber C a P, (μ (treeCell q)).toReal := by |
| rw [restriction_prefix_mass μ ha hC hP, ENNReal.toReal_sum] |
| intro q _ |
| exact measure_ne_top _ _ |
|
|
| theorem restriction_prefix_mass_bounds (μ : Measure (EuclideanSpace ℝ (Fin d))) [IsFiniteMeasure μ] |
| {N a : ℕ} (ha : a ≤ N) {C : Finset (CellPath d)} (hC : C ⊆ dyadicPaths N) |
| {P : (CellPath d)} (hP : P.length = a) {s : ℝ} |
| (hm : ∀ q ∈ C, s ≤ (μ (treeCell q)).toReal ∧ |
| (μ (treeCell q)).toReal ≤ 2*s) : |
| (prefixFiber C a P).card * s ≤ |
| ((μ.restrict (leafUnion C)) (treeCell P)).toReal ∧ |
| ((μ.restrict (leafUnion C)) (treeCell P)).toReal ≤ |
| (prefixFiber C a P).card * (2*s) := by |
| rw [restriction_prefix_mass_real μ ha hC hP] |
| constructor |
| · calc |
| _ = ∑ _q ∈ prefixFiber C a P, s := by simp |
| _ ≤ _ := Finset.sum_le_sum fun q hq => (hm q (Finset.mem_filter.mp hq).1).1 |
| · calc |
| _ ≤ ∑ _q ∈ prefixFiber C a P, 2*s := |
| Finset.sum_le_sum fun q hq => (hm q (Finset.mem_filter.mp hq).1).2 |
| _ = _ := by simp |
|
|
| theorem restriction_total_mass_real (μ : Measure (EuclideanSpace ℝ (Fin d))) [IsFiniteMeasure μ] |
| {N : ℕ} {C : Finset (CellPath d)} (hC : C ⊆ dyadicPaths N) : |
| (μ (leafUnion C)).toReal = ∑ q ∈ C, (μ (treeCell q)).toReal := by |
| rw [measure_leafUnion μ hC, ENNReal.toReal_sum] |
| intro q _; exact measure_ne_top _ _ |
|
|
| theorem restriction_total_mass_bounds (μ : Measure (EuclideanSpace ℝ (Fin d))) [IsFiniteMeasure μ] |
| {N : ℕ} {C : Finset (CellPath d)} (hC : C ⊆ dyadicPaths N) {s : ℝ} |
| (hm : ∀ q ∈ C, s ≤ (μ (treeCell q)).toReal ∧ |
| (μ (treeCell q)).toReal ≤ 2*s) : |
| C.card*s ≤ (μ (leafUnion C)).toReal ∧ |
| (μ (leafUnion C)).toReal ≤ C.card*(2*s) := by |
| rw [restriction_total_mass_real μ hC] |
| constructor |
| · calc |
| _ = ∑ _q ∈ C, s := by simp |
| _ ≤ _ := Finset.sum_le_sum fun q hq => (hm q hq).1 |
| · calc |
| _ ≤ ∑ _q ∈ C, 2*s := Finset.sum_le_sum fun q hq => (hm q hq).2 |
| _ = _ := by simp |
|
|
| theorem leafUnion_all (N : ℕ) : leafUnion (dyadicPaths (d := d) N) = treeCell [] := treeCell_cover_root N |
|
|
| end CurrentFalconer.TreeND |
| end GraphLiteralSupport |
| end |
| end |
|
|
| end OAI |
|
|
