| import Mathlib |
|
|
| namespace OAI |
|
|
| namespace LargeIndependentSets |
| open Filter |
|
|
| abbrev ListIndex (s : ℕ) (X : Type*) := |
| {I : Finset X // I.Nonempty ∧ I.card ≤ s} |
|
|
| abbrev ListSlot (s d : ℕ) (X : Type*) := ListIndex s X × Fin d |
|
|
| abbrev EqualityData (s d : ℕ) (X : Type*) := ListSlot s d X → ListSlot s d X → Bool |
|
|
| def IsPattern {s d : ℕ} {X : Type*} [LinearOrder X] |
| (C : EqualityData s d X) : Prop := |
| (∀ a b, C a b = true → C b a = true) ∧ |
| (∀ a b c, C a b = true → C b c = true → C a c = true) ∧ |
| (∀ a b, C a b = true → a.1 = b.1 → a.2 = b.2) ∧ |
| (∀ a b, (∀ x ∈ a.1.val, ∀ y ∈ b.1.val, x < y) → C a b = false) |
|
|
| abbrev ListPattern (s d : ℕ) (X : Type*) [LinearOrder X] := |
| {C : EqualityData s d X // IsPattern C} |
|
|
| lemma isClosed_isPattern (s d : ℕ) (X : Type*) [LinearOrder X] : |
| IsClosed {C : EqualityData s d X | IsPattern C} := by |
| classical |
| have ev (a b : ListSlot s d X) : Continuous (fun C : EqualityData s d X => C a b) := |
| (continuous_apply b).comp (continuous_apply a) |
| have cl (a b : ListSlot s d X) (v : Bool) : |
| IsClosed {C : EqualityData s d X | C a b = v} := |
| isClosed_eq (ev a b) continuous_const |
| have op (a b : ListSlot s d X) (v : Bool) : |
| IsOpen {C : EqualityData s d X | C a b = v} := |
| (isOpen_discrete {v}).preimage (ev a b) |
| have hsym : IsClosed {C : EqualityData s d X | |
| ∀ a b, C a b = true → C b a = true} := by |
| simp only [Set.ofPred_forall] |
| apply isClosed_iInter; intro a |
| apply isClosed_iInter; intro b |
| convert (op a b true).isClosed_compl.union (cl b a true) using 1 |
| ext C; simp only [Set.mem_ofPred_eq, Set.mem_union, Set.mem_compl_iff]; tauto |
| have htrans : IsClosed {C : EqualityData s d X | |
| ∀ a b c, C a b = true → C b c = true → C a c = true} := by |
| simp only [Set.ofPred_forall] |
| apply isClosed_iInter; intro a |
| apply isClosed_iInter; intro b |
| apply isClosed_iInter; intro c |
| convert (op a b true).isClosed_compl.union |
| ((op b c true).isClosed_compl.union (cl a c true)) using 1 |
| ext C; simp only [Set.mem_ofPred_eq, Set.mem_union, Set.mem_compl_iff]; tauto |
| have hinj : IsClosed {C : EqualityData s d X | |
| ∀ a b, C a b = true → a.1 = b.1 → a.2 = b.2} := by |
| simp only [Set.ofPred_forall] |
| apply isClosed_iInter; intro a |
| apply isClosed_iInter; intro b |
| by_cases h : a.1 = b.1 → a.2 = b.2 |
| · have he : {C : EqualityData s d X | C a b = true → a.1 = b.1 → a.2 = b.2} = Set.univ := by |
| ext C; simp only [Set.mem_ofPred_eq, Set.mem_univ, iff_true]; exact fun _ => h |
| rw [he]; exact isClosed_univ |
| · convert (op a b true).isClosed_compl using 1 |
| ext C; simp only [Set.mem_ofPred_eq, Set.mem_compl_iff]; tauto |
| have hsep : IsClosed {C : EqualityData s d X | |
| ∀ a b, (∀ x ∈ a.1.val, ∀ y ∈ b.1.val, x < y) → C a b = false} := by |
| simp only [Set.ofPred_forall] |
| apply isClosed_iInter; intro a |
| apply isClosed_iInter; intro b |
| apply isClosed_iInter; intro _ |
| exact cl a b false |
| exact hsym.inter (htrans.inter (hinj.inter hsep)) |
|
|
| instance (s d : ℕ) (X : Type*) [LinearOrder X] : CompactSpace (ListPattern s d X) := |
| isCompact_iff_compactSpace.mp (isClosed_isPattern s d X).isCompact |
|
|
| noncomputable instance (s d : ℕ) (X : Type*) [LinearOrder X] [Fintype X] : |
| Fintype (ListPattern s d X) := Fintype.ofFinite _ |
|
|
| instance (s d : ℕ) (X : Type*) [LinearOrder X] : Inhabited (ListPattern s d X) := |
| ⟨⟨fun _ _ => false, by simp [IsPattern]⟩⟩ |
|
|
| def ListIndex.map {s : ℕ} {X Y : Type*} (e : X ↪ Y) (I : ListIndex s X) : |
| ListIndex s Y := |
| ⟨I.val.map e, I.property.1.map, by simpa using I.property.2⟩ |
|
|
| def ListSlot.map {s d : ℕ} {X Y : Type*} (e : X ↪ Y) (a : ListSlot s d X) : |
| ListSlot s d Y := (ListIndex.map e a.1, a.2) |
|
|
| lemma ListIndex.map_injective {s : ℕ} {X Y : Type*} (e : X ↪ Y) : |
| Function.Injective (ListIndex.map (s := s) e) := by |
| intro I J h |
| apply Subtype.ext |
| exact Finset.map_injective e (congrArg Subtype.val h) |
|
|
| lemma ListSlot.map_injective {s d : ℕ} {X Y : Type*} (e : X ↪ Y) : |
| Function.Injective (ListSlot.map (s := s) (d := d) e) := by |
| intro a b h |
| exact Prod.ext (ListIndex.map_injective e (congrArg Prod.fst h)) |
| (show a.2 = b.2 from congrArg (fun c : ListSlot s d Y => c.2) h) |
|
|
| def ListPattern.restrict {s d : ℕ} {X Y : Type*} [LinearOrder X] [LinearOrder Y] |
| (e : X ↪o Y) (C : ListPattern s d Y) : ListPattern s d X := |
| ⟨fun a b => C.val (ListSlot.map e.toEmbedding a) (ListSlot.map e.toEmbedding b), by |
| refine ⟨?_, ?_, ?_, ?_⟩ |
| · intro a b h; exact C.property.1 _ _ h |
| · intro a b c hab hbc; exact C.property.2.1 _ _ _ hab hbc |
| · intro a b h hab |
| exact C.property.2.2.1 _ _ h (congrArg (ListIndex.map e.toEmbedding) hab) |
| · intro a b hsep |
| apply C.property.2.2.2 |
| intro x hx y hy |
| obtain ⟨i, hi, rfl⟩ := Finset.mem_map.mp hx |
| obtain ⟨j, hj, rfl⟩ := Finset.mem_map.mp hy |
| exact e.strictMono (hsep i hi j hj)⟩ |
|
|
| lemma ListPattern.continuous_restrict {s d : ℕ} {X Y : Type*} |
| [LinearOrder X] [LinearOrder Y] (e : X ↪o Y) : |
| Continuous (ListPattern.restrict (s := s) (d := d) e) := by |
| apply Continuous.subtype_mk |
| apply continuous_pi; intro a |
| apply continuous_pi; intro b |
| exact ((continuous_apply (ListSlot.map e.toEmbedding b)).comp |
| (continuous_apply (ListSlot.map e.toEmbedding a) : |
| Continuous (fun C : EqualityData s d Y => C (ListSlot.map e.toEmbedding a)))).comp |
| continuous_subtype_val |
|
|
| lemma ListIndex.min_map {s : ℕ} {X Y : Type*} [LinearOrder X] [LinearOrder Y] |
| (e : X ↪o Y) (I : ListIndex s X) : |
| (ListIndex.map e.toEmbedding I).val.min' (ListIndex.map e.toEmbedding I).property.1 = |
| e (I.val.min' I.property.1) := by |
| apply le_antisymm |
| · apply Finset.min'_le |
| exact Finset.mem_map.mpr ⟨_, Finset.min'_mem _ _, rfl⟩ |
| · obtain ⟨x, hx, he⟩ := Finset.mem_map.mp |
| (Finset.min'_mem (ListIndex.map e.toEmbedding I).val _) |
| rw [← he] |
| exact e.monotone (Finset.min'_le _ _ hx) |
|
|
| lemma ListPattern.occupied_of_eq {s d : ℕ} {X : Type*} [LinearOrder X] |
| (C : ListPattern s d X) {a b : ListSlot s d X} (h : C.val a b = true) : |
| C.val a a = true := C.property.2.1 _ _ _ h (C.property.1 _ _ h) |
|
|
| lemma ListPattern.min_le_max {s d : ℕ} {X : Type*} [LinearOrder X] |
| (C : ListPattern s d X) {a b : ListSlot s d X} (h : C.val a b = true) : |
| b.1.val.min' b.1.property.1 ≤ a.1.val.max' a.1.property.1 := by |
| by_contra hn |
| have hlt := lt_of_not_ge hn |
| have hh := C.property.2.2.2 a b (by |
| intro x hx y hy |
| exact lt_of_le_of_lt (Finset.le_max' _ _ hx) |
| (lt_of_lt_of_le hlt (Finset.min'_le _ _ hy))) |
| exact Bool.false_ne_true (hh.symm.trans h) |
|
|
| noncomputable def patternCutValues {s d : ℕ} (C : ListPattern s d ℚ) |
| (a : ListSlot s d ℚ) : Set ℝ := |
| insert ((a.1.val.min' a.1.property.1 : ℚ) : ℝ) |
| {x | ∃ b : ListSlot s d ℚ, C.val a b = true ∧ |
| x = (b.1.val.min' b.1.property.1 : ℚ)} |
|
|
| lemma patternCutValues_nonempty {s d : ℕ} (C : ListPattern s d ℚ) |
| (a : ListSlot s d ℚ) : (patternCutValues C a).Nonempty := ⟨_, Or.inl rfl⟩ |
|
|
| lemma patternCutValues_bddAbove {s d : ℕ} (C : ListPattern s d ℚ) |
| (a : ListSlot s d ℚ) : BddAbove (patternCutValues C a) := by |
| refine ⟨(a.1.val.max' a.1.property.1 : ℚ), ?_⟩ |
| intro x hx |
| rcases hx with rfl | ⟨b, hab, rfl⟩ |
| · exact_mod_cast Finset.min'_le _ _ (Finset.max'_mem _ _) |
| · exact_mod_cast C.min_le_max hab |
|
|
| noncomputable def patternCut {s d : ℕ} (C : ListPattern s d ℚ) |
| (a : ListSlot s d ℚ) : ℝ := sSup (patternCutValues C a) |
|
|
| lemma patternCut_le_iff {s d : ℕ} (C : ListPattern s d ℚ) |
| (a : ListSlot s d ℚ) (q : ℝ) : |
| patternCut C a ≤ q ↔ |
| (a.1.val.min' a.1.property.1 : ℚ) ≤ q ∧ |
| ∀ b, C.val a b = true → (b.1.val.min' b.1.property.1 : ℚ) ≤ q := by |
| rw [patternCut, csSup_le_iff (patternCutValues_bddAbove C a) |
| (patternCutValues_nonempty C a)] |
| constructor |
| · intro h |
| exact ⟨h _ (Or.inl rfl), fun b hb => h _ (Or.inr ⟨b, hb, rfl⟩)⟩ |
| · rintro ⟨ha, hb⟩ x (rfl | ⟨b, hab, rfl⟩) |
| · exact ha |
| · exact hb b hab |
|
|
| lemma patternCut_hull {s d : ℕ} (C : ListPattern s d ℚ) |
| (a : ListSlot s d ℚ) : |
| (a.1.val.min' a.1.property.1 : ℚ) ≤ patternCut C a ∧ |
| patternCut C a ≤ (a.1.val.max' a.1.property.1 : ℚ) := by |
| constructor |
| · exact le_csSup (patternCutValues_bddAbove C a) (Or.inl rfl) |
| · apply (patternCut_le_iff C a _).mpr |
| constructor |
| · exact_mod_cast Finset.min'_le _ _ (Finset.max'_mem _ _) |
| · intro b hb; exact_mod_cast C.min_le_max hb |
|
|
| lemma patternCut_eq_of_eq {s d : ℕ} (C : ListPattern s d ℚ) |
| (a b : ListSlot s d ℚ) (hab : C.val a b = true) : |
| patternCut C a = patternCut C b := by |
| have hv (a b : ListSlot s d ℚ) (hab : C.val a b = true) : |
| patternCutValues C a ⊆ patternCutValues C b := by |
| intro x hx |
| rcases hx with rfl | ⟨c, hc, rfl⟩ |
| · exact Or.inr ⟨a, C.property.1 a b hab, rfl⟩ |
| · exact Or.inr ⟨c, C.property.2.1 b a c (C.property.1 a b hab) hc, rfl⟩ |
| exact congrArg sSup (Set.Subset.antisymm (hv a b hab) (hv b a (C.property.1 a b hab))) |
|
|
| lemma patternEval_continuous {s d : ℕ} {X : Type*} [LinearOrder X] |
| (a b : ListSlot s d X) : Continuous (fun C : ListPattern s d X => C.val a b) := |
| ((continuous_apply b).comp (continuous_apply a : |
| Continuous (fun C : EqualityData s d X => C a))).comp continuous_subtype_val |
|
|
| lemma patternCut_measurable {s d : ℕ} (a : ListSlot s d ℚ) : |
| Measurable (fun C : ListPattern s d ℚ => patternCut C a) := by |
| classical |
| apply measurable_of_Iic |
| intro q |
| have he : (fun C : ListPattern s d ℚ => patternCut C a) ⁻¹' Set.Iic q = |
| {C : ListPattern s d ℚ | (a.1.val.min' a.1.property.1 : ℚ) ≤ q} ∩ |
| ⋂ b : ListSlot s d ℚ, {C : ListPattern s d ℚ | |
| C.val a b = true → (b.1.val.min' b.1.property.1 : ℚ) ≤ q} := by |
| ext C |
| simp only [Set.mem_preimage, Set.mem_Iic, Set.mem_inter_iff, |
| Set.mem_ofPred_eq, Set.mem_iInter, patternCut_le_iff] |
| rw [he] |
| apply MeasurableSet.inter (by |
| by_cases h : ((a.1.val.min' a.1.property.1 : ℚ) : ℝ) ≤ q <;> simp [h]) |
| apply MeasurableSet.iInter; intro b |
| by_cases h : (b.1.val.min' b.1.property.1 : ℚ) ≤ q |
| · simp only [h, implies_true, Set.ofPred_true]; exact MeasurableSet.univ |
| · have he : {C : ListPattern s d ℚ | |
| C.val a b = true → (b.1.val.min' b.1.property.1 : ℚ) ≤ q} = |
| {C : ListPattern s d ℚ | C.val a b = true}ᶜ := by |
| ext C; simp only [Set.mem_ofPred_eq, Set.mem_compl_iff]; tauto |
| rw [he] |
| exact ((isClosed_eq (patternEval_continuous a b) continuous_const).measurableSet).compl |
|
|
| noncomputable def ListIndex.mapEquiv {s : ℕ} {X Y : Type*} |
| [LinearOrder X] [LinearOrder Y] (e : X ≃o Y) : ListIndex s X ≃ ListIndex s Y where |
| toFun := ListIndex.map e.toEmbedding |
| invFun := ListIndex.map e.symm.toEmbedding |
| left_inv I := by |
| apply Subtype.ext |
| ext x |
| simp [ListIndex.map] |
| right_inv I := by |
| apply Subtype.ext |
| ext x |
| simp [ListIndex.map] |
|
|
| noncomputable def ListSlot.mapEquiv {s d : ℕ} {X Y : Type*} |
| [LinearOrder X] [LinearOrder Y] (e : X ≃o Y) : ListSlot s d X ≃ ListSlot s d Y := |
| (ListIndex.mapEquiv e).prodCongr (Equiv.refl (Fin d)) |
|
|
| lemma ListSlot.mapEquiv_apply {s d : ℕ} {X Y : Type*} |
| [LinearOrder X] [LinearOrder Y] (e : X ≃o Y) (a : ListSlot s d X) : |
| ListSlot.mapEquiv e a = ListSlot.map e.toEmbedding a := rfl |
|
|
| lemma patternCut_rat_iff {s d : ℕ} (C : ListPattern s d ℚ) |
| (a : ListSlot s d ℚ) (q : ℚ) : |
| patternCut C a ≤ (q : ℝ) ↔ |
| a.1.val.min' a.1.property.1 ≤ q ∧ |
| ∀ b, C.val a b = true → b.1.val.min' b.1.property.1 ≤ q := by |
| simpa only [Rat.cast_le] using patternCut_le_iff C a (q : ℝ) |
|
|
| lemma patternCut_restrict_CDF {s d : ℕ} (C : ListPattern s d ℚ) |
| (e : ℚ ≃o ℚ) (a : ListSlot s d ℚ) (q : ℚ) : |
| patternCut (ListPattern.restrict e.toOrderEmbedding C) a ≤ (q : ℝ) ↔ |
| patternCut C (ListSlot.map e.toEmbedding a) ≤ (e q : ℝ) := by |
| have hmin (I : ListIndex s ℚ) : |
| (ListIndex.map e.toEmbedding I).val.min' _ = e (I.val.min' I.property.1) := |
| ListIndex.min_map e.toOrderEmbedding I |
| rw [patternCut_rat_iff, patternCut_rat_iff] |
| change (_ ≤ q ∧ ∀ b, C.val (ListSlot.map e.toEmbedding a) |
| (ListSlot.map e.toEmbedding b) = true → _ ≤ q) ↔ _ |
| rw [show (ListSlot.map e.toEmbedding a).1 = ListIndex.map e.toEmbedding a.1 from rfl, |
| hmin, e.le_iff_le] |
| constructor |
| · rintro ⟨ha, h⟩ |
| refine ⟨ha, ?_⟩ |
| intro b hb |
| obtain ⟨b', rfl⟩ := (ListSlot.mapEquiv (s := s) (d := d) e).surjective b |
| change (ListIndex.map e.toEmbedding b'.1).val.min' _ ≤ e q |
| rw [hmin, e.le_iff_le] |
| exact h b' hb |
| · rintro ⟨ha, h⟩ |
| refine ⟨ha, ?_⟩ |
| intro b hb |
| have hh := h (ListSlot.map e.toEmbedding b) hb |
| change (ListIndex.map e.toEmbedding b.1).val.min' _ ≤ e q at hh |
| rwa [hmin, e.le_iff_le] at hh |
|
|
| lemma ListSlot.map_eq_self {s d : ℕ} (e : ℚ ≃o ℚ) (a : ListSlot s d ℚ) |
| (he : ∀ i ∈ a.1.val, e i = i) : ListSlot.map e.toEmbedding a = a := by |
| apply Prod.ext |
| · apply Subtype.ext |
| ext x |
| constructor |
| · intro hx |
| obtain ⟨y, hy, hxy⟩ := Finset.mem_map.mp hx |
| change e y = x at hxy |
| rw [he y hy] at hxy |
| exact hxy ▸ hy |
| · intro hx |
| exact Finset.mem_map.mpr ⟨x, hx, he x hx⟩ |
| · rfl |
|
|
| open MeasureTheory Set in |
|
|
| theorem invariant_cut_support_open (I : Finset ℚ) (ν : Measure ℝ) [IsFiniteMeasure ν] |
| (hCDF : ∀ a b : ℚ, a < b → a ∉ I → b ∉ I → |
| (∀ i ∈ I, i < a ↔ i < b) → ν (Iic (a : ℝ)) = ν (Iic (b : ℝ))) : |
| ν (((↑I : Set ℚ).image ((↑) : ℚ → ℝ))ᶜ) = 0 := by |
| classical |
| let Intervals := {p : ℚ × ℚ // p.1 < p.2 ∧ p.1 ∉ I ∧ p.2 ∉ I ∧ |
| ∀ i ∈ I, i < p.1 ↔ i < p.2} |
| have hnull (p : Intervals) : ν (Ioc (p.val.1 : ℝ) (p.val.2 : ℝ)) = 0 := by |
| have hp : (p.val.1 : ℝ) ≤ (p.val.2 : ℝ) := by exact_mod_cast p.property.1.le |
| rw [← Iic_sdiff_Iic, measure_sdiff (Iic_subset_Iic.mpr hp) |
| measurableSet_Iic.nullMeasurableSet (measure_ne_top ν _)] |
| rw [hCDF _ _ p.property.1 p.property.2.1 p.property.2.2.1 p.property.2.2.2, tsub_self] |
| apply measure_mono_null (t := ⋃ p : Intervals, Ioc (p.val.1 : ℝ) (p.val.2 : ℝ)) |
| · intro x hx |
| have hclosed : IsClosed ((↑I : Set ℚ).image ((↑) : ℚ → ℝ)) := |
| (I.finite_toSet.image _).isClosed |
| obtain ⟨u, v, huxv, huv⟩ := mem_nhds_iff_exists_Ioo_subset.mp |
| (hclosed.isOpen_compl.mem_nhds hx) |
| obtain ⟨a, hua, hax⟩ := exists_rat_btwn huxv.1 |
| obtain ⟨b, hxb, hbv⟩ := exists_rat_btwn huxv.2 |
| have hab : a < b := by exact_mod_cast hax.trans hxb |
| have ha : a ∉ I := by |
| intro ha |
| exact (huv ⟨hua, hax.trans huxv.2⟩) ⟨a, ha, rfl⟩ |
| have hb : b ∉ I := by |
| intro hb |
| exact (huv ⟨huxv.1.trans hxb, hbv⟩) ⟨b, hb, rfl⟩ |
| have hg : ∀ i ∈ I, i < a ↔ i < b := by |
| intro i hi |
| constructor |
| · intro hia; exact hia.trans hab |
| · intro hib |
| by_contra hia |
| have hai := le_of_not_gt hia |
| have hai' : (a : ℝ) ≤ (i : ℝ) := by exact_mod_cast hai |
| have hib' : (i : ℝ) < (b : ℝ) := by exact_mod_cast hib |
| exact (huv ⟨hua.trans_le hai', hib'.trans hbv⟩) ⟨i, hi, rfl⟩ |
| exact mem_iUnion.mpr ⟨⟨(a, b), hab, ha, hb, hg⟩, hax, hxb.le⟩ |
| · exact measure_iUnion_null hnull |
|
|
| end LargeIndependentSets |
|
|
| end OAI |
|
|
