| import Mathlib |
| import OAI.Combinatorics.IndependentSets.Reduction.ListIndex |
| import OAI.Combinatorics.IndependentSets.Reduction.ExtendPartialIso |
|
|
| namespace OAI |
|
|
| namespace LargeIndependentSets |
| open MeasureTheory Set |
|
|
| def PatternInvariant {s d : ℕ} (μ : Measure (ListPattern s d ℚ)) : Prop := |
| ∀ e : ℚ ≃o ℚ, Measure.map (ListPattern.restrict e.toOrderEmbedding) μ = μ |
|
|
| lemma occupied_measurable {s d : ℕ} (a : ListSlot s d ℚ) : |
| MeasurableSet {C : ListPattern s d ℚ | C.val a a = true} := |
| (isClosed_eq (patternEval_continuous a a) continuous_const).measurableSet |
|
|
| theorem invariant_pattern_cut_in_list {s d : ℕ} (μ : Measure (ListPattern s d ℚ)) |
| [IsFiniteMeasure μ] (hinv : PatternInvariant μ) (a : ListSlot s d ℚ) : |
| μ {C | C.val a a = true ∧ |
| patternCut C a ∉ ((↑a.1.val : Set ℚ).image ((↑) : ℚ → ℝ))} = 0 := by |
| classical |
| let E : Set (ListPattern s d ℚ) := {C | C.val a a = true} |
| let ν : Measure ℝ := Measure.map (fun C => patternCut C a) (μ.restrict E) |
| have hCDF (x y : ℚ) (hxy : x < y) (hx : x ∉ a.1.val) (hy : y ∉ a.1.val) |
| (hcut : ∀ i ∈ a.1.val, i < x ↔ i < y) : ν (Iic (x : ℝ)) = ν (Iic (y : ℝ)) := by |
| obtain ⟨e, hexy, hefix⟩ := rational_automorphism_fixing a.1.val x y hx hy hcut |
| have hea := ListSlot.map_eq_self e a hefix |
| let F : Set (ListPattern s d ℚ) := |
| (fun C => patternCut C a) ⁻¹' Iic (x : ℝ) ∩ E |
| have hF : MeasurableSet F := |
| ((patternCut_measurable a) measurableSet_Iic).inter (occupied_measurable a) |
| have hh := congrArg (fun τ : Measure (ListPattern s d ℚ) => τ F) (hinv e) |
| rw [Measure.map_apply (ListPattern.continuous_restrict e.toOrderEmbedding).measurable hF] at hh |
| have hfpre : (ListPattern.restrict e.toOrderEmbedding) ⁻¹' F = |
| (fun C => patternCut C a) ⁻¹' Iic (y : ℝ) ∩ E := by |
| ext C |
| change (patternCut (ListPattern.restrict e.toOrderEmbedding C) a ≤ (x : ℝ) ∧ |
| C.val (ListSlot.map e.toEmbedding a) (ListSlot.map e.toEmbedding a) = true) ↔ |
| (patternCut C a ≤ (y : ℝ) ∧ C.val a a = true) |
| rw [patternCut_restrict_CDF, hea, hexy] |
| rw [hfpre] at hh |
| dsimp only [ν] |
| rw [Measure.map_apply (patternCut_measurable a) measurableSet_Iic, |
| Measure.map_apply (patternCut_measurable a) measurableSet_Iic, |
| Measure.restrict_apply ((patternCut_measurable a) measurableSet_Iic), |
| Measure.restrict_apply ((patternCut_measurable a) measurableSet_Iic)] |
| exact hh.symm |
| have hz := invariant_cut_support_open a.1.val ν hCDF |
| have hcomp : MeasurableSet (((↑a.1.val : Set ℚ).image ((↑) : ℚ → ℝ))ᶜ) := |
| (a.1.val.finite_toSet.image _).measurableSet.compl |
| dsimp only [ν] at hz |
| rw [Measure.map_apply (patternCut_measurable a) hcomp, |
| Measure.restrict_apply ((patternCut_measurable a) hcomp)] at hz |
| convert hz using 2 |
| ext C |
| change (_ ∧ _) ↔ (_ ∧ _) |
| tauto |
|
|
| def GloballyAligned {s d : ℕ} (C : ListPattern s d ℚ) : Prop := |
| ∀ a, C.val a a = true → ∃ i : ℚ, ∀ b, C.val a b = true → i ∈ b.1.val |
|
|
| theorem invariant_pattern_globally_aligned {s d : ℕ} |
| (μ : Measure (ListPattern s d ℚ)) [IsFiniteMeasure μ] (hinv : PatternInvariant μ) : |
| ∀ᵐ C ∂μ, GloballyAligned C := by |
| have ha (a : ListSlot s d ℚ) : ∀ᵐ C ∂μ, C.val a a = true → |
| patternCut C a ∈ ((↑a.1.val : Set ℚ).image ((↑) : ℚ → ℝ)) := by |
| apply ae_iff.mpr |
| convert invariant_pattern_cut_in_list μ hinv a using 2 |
| ext C |
| exact Classical.not_imp |
| have hall : ∀ᵐ C ∂μ, ∀ a : ListSlot s d ℚ, C.val a a = true → |
| patternCut C a ∈ ((↑a.1.val : Set ℚ).image ((↑) : ℚ → ℝ)) := |
| ae_all_iff.mpr ha |
| filter_upwards [hall] with C hC |
| intro a haa |
| obtain ⟨i, hi, hic⟩ := hC a haa |
| refine ⟨i, ?_⟩ |
| intro b hab |
| have hbb : C.val b b = true := C.occupied_of_eq (C.property.1 a b hab) |
| obtain ⟨j, hj, hjc⟩ := hC b hbb |
| have hij : (i : ℝ) = (j : ℝ) := hic.trans ((patternCut_eq_of_eq C a b hab).trans hjc.symm) |
| have hij' : i = j := by exact_mod_cast hij |
| exact hij' ▸ hj |
|
|
| def GoodPatternOn {s d : ℕ} {X : Type*} [LinearOrder X] |
| (C : ListPattern s d X) (B : Finset X) : Prop := |
| ∀ a, a.1.val ⊆ B → C.val a a = true → ∃ i ∈ B, |
| ∀ b, b.1.val ⊆ B → C.val a b = true → i ∈ b.1.val |
|
|
| lemma GloballyAligned.goodOn {s d : ℕ} (C : ListPattern s d ℚ) |
| (h : GloballyAligned C) (B : Finset ℚ) : GoodPatternOn C B := by |
| intro a ha haa |
| obtain ⟨i, hi⟩ := h a haa |
| exact ⟨i, ha (hi a haa), fun b _ hab => hi b hab⟩ |
|
|
| theorem invariant_pattern_no_bad_sets {s d : ℕ} |
| (μ : Measure (ListPattern s d ℚ)) [IsFiniteMeasure μ] (hinv : PatternInvariant μ) |
| (B : Finset ℚ) : μ {C | ¬GoodPatternOn C B} = 0 := by |
| have h : ∀ᵐ C ∂μ, GoodPatternOn C B := |
| (invariant_pattern_globally_aligned μ hinv).mono (fun C h => h.goodOn C B) |
| exact ae_iff.mp h |
|
|
| noncomputable def ListIndex.inside {s : ℕ} {X : Type*} [LinearOrder X] |
| (B : Finset X) (I : ListIndex s X) (h : I.val ⊆ B) : ListIndex s B := by |
| classical |
| refine ⟨I.val.subtype (· ∈ B), ?_, ?_⟩ |
| · obtain ⟨x, hx⟩ := I.property.1 |
| exact ⟨⟨x, h hx⟩, Finset.mem_subtype.mpr hx⟩ |
| · exact (Finset.card_subtype _ _).trans_le |
| ((Finset.card_filter_le _ _).trans I.property.2) |
|
|
| lemma ListIndex.map_inside {s : ℕ} {X : Type*} [LinearOrder X] |
| (B : Finset X) (I : ListIndex s X) (h : I.val ⊆ B) : |
| ListIndex.map (Function.Embedding.subtype (· ∈ B)) (I.inside B h) = I := by |
| classical |
| apply Subtype.ext |
| exact Finset.subtype_map_of_mem (fun x hx => h hx) |
|
|
| noncomputable def ListSlot.inside {s d : ℕ} {X : Type*} [LinearOrder X] |
| (B : Finset X) (a : ListSlot s d X) (h : a.1.val ⊆ B) : ListSlot s d B := |
| (a.1.inside B h, a.2) |
|
|
| lemma ListSlot.map_inside {s d : ℕ} {X : Type*} [LinearOrder X] |
| (B : Finset X) (a : ListSlot s d X) (h : a.1.val ⊆ B) : |
| ListSlot.map (Function.Embedding.subtype (· ∈ B)) (a.inside B h) = a := by |
| exact Prod.ext (ListIndex.map_inside B a.1 h) rfl |
|
|
| noncomputable def liftData {s d : ℕ} {X : Type*} [LinearOrder X] |
| (B : Finset X) (C : ListPattern s d B) : EqualityData s d X := by |
| classical |
| exact fun a b => if ha : a.1.val ⊆ B then |
| if hb : b.1.val ⊆ B then C.val (a.inside B ha) (b.inside B hb) else false else false |
|
|
| lemma liftData_true_iff {s d : ℕ} {X : Type*} [LinearOrder X] |
| (B : Finset X) (C : ListPattern s d B) (a b : ListSlot s d X) : |
| liftData B C a b = true ↔ ∃ ha : a.1.val ⊆ B, ∃ hb : b.1.val ⊆ B, |
| C.val (a.inside B ha) (b.inside B hb) = true := by |
| classical |
| simp only [liftData] |
| split_ifs <;> simp_all |
|
|
| noncomputable def ListPattern.lift {s d : ℕ} {X : Type*} [LinearOrder X] |
| (B : Finset X) (C : ListPattern s d B) : ListPattern s d X := by |
| classical |
| refine ⟨liftData B C, ?_, ?_, ?_, ?_⟩ |
| · intro a b h |
| obtain ⟨ha, hb, hab⟩ := (liftData_true_iff B C a b).mp h |
| exact (liftData_true_iff B C b a).mpr ⟨hb, ha, C.property.1 _ _ hab⟩ |
| · intro a b c hab hbc |
| obtain ⟨ha, hb, hab⟩ := (liftData_true_iff B C a b).mp hab |
| obtain ⟨_, hc, hbc⟩ := (liftData_true_iff B C b c).mp hbc |
| exact (liftData_true_iff B C a c).mpr ⟨ha, hc, C.property.2.1 _ _ _ hab hbc⟩ |
| · intro a b hab habI |
| obtain ⟨ha, hb, hab⟩ := (liftData_true_iff B C a b).mp hab |
| apply C.property.2.2.1 _ _ hab |
| change ListIndex.inside B a.1 ha = ListIndex.inside B b.1 hb |
| apply Subtype.ext |
| change a.1.val.subtype (· ∈ B) = b.1.val.subtype (· ∈ B) |
| rw [congrArg Subtype.val habI] |
| · intro a b hsep |
| apply Bool.eq_false_iff.mpr |
| intro hab |
| obtain ⟨ha, hb, hab⟩ := (liftData_true_iff B C a b).mp hab |
| have hf := C.property.2.2.2 (a.inside B ha) (b.inside B hb) (by |
| intro x hx y hy |
| exact hsep x.val (Finset.mem_subtype.mp hx) y.val (Finset.mem_subtype.mp hy)) |
| exact Bool.false_ne_true (hf.symm.trans hab) |
|
|
| lemma ListSlot.inside_map {s d : ℕ} {X : Type*} [LinearOrder X] |
| (B : Finset X) (a : ListSlot s d B) |
| (h : (ListSlot.map (Function.Embedding.subtype (· ∈ B)) a).1.val ⊆ B) : |
| (ListSlot.map (Function.Embedding.subtype (· ∈ B)) a).inside B h = a := by |
| apply ListSlot.map_injective (Function.Embedding.subtype (· ∈ B)) |
| exact ListSlot.map_inside B _ h |
|
|
| lemma ListPattern.restrict_lift {s d : ℕ} {X : Type*} [LinearOrder X] |
| (B : Finset X) (C : ListPattern s d B) : |
| ListPattern.restrict (OrderEmbedding.subtype (· ∈ B)) (C.lift B) = C := by |
| classical |
| apply Subtype.ext |
| funext a b |
| have h (a : ListSlot s d B) : |
| (ListSlot.map (Function.Embedding.subtype (· ∈ B)) a).1.val ⊆ B := by |
| intro x hx |
| obtain ⟨y, hy, rfl⟩ := Finset.mem_map.mp hx |
| exact y.property |
| change liftData B C (ListSlot.map (Function.Embedding.subtype (· ∈ B)) a) |
| (ListSlot.map (Function.Embedding.subtype (· ∈ B)) b) = _ |
| simp only [liftData, dite_eq_left (h a), dite_eq_left (h b), ListSlot.inside_map] |
|
|
| lemma ListIndex.map_id {s : ℕ} {X : Type*} (I : ListIndex s X) : |
| ListIndex.map (Function.Embedding.refl X) I = I := by |
| apply Subtype.ext |
| exact Finset.map_refl |
|
|
| lemma ListSlot.map_id {s d : ℕ} {X : Type*} (a : ListSlot s d X) : |
| ListSlot.map (Function.Embedding.refl X) a = a := |
| Prod.ext (ListIndex.map_id a.1) rfl |
|
|
| lemma ListSlot.map_comp {s d : ℕ} {X Y Z : Type*} (e : X ↪ Y) (f : Y ↪ Z) |
| (a : ListSlot s d X) : |
| ListSlot.map f (ListSlot.map e a) = ListSlot.map (e.trans f) a := by |
| apply Prod.ext |
| · apply Subtype.ext |
| exact Finset.map_map _ _ _ |
| · rfl |
|
|
| lemma ListPattern.restrict_id {s d : ℕ} {X : Type*} [LinearOrder X] |
| (C : ListPattern s d X) : ListPattern.restrict ((OrderIso.refl X).toOrderEmbedding) C = C := by |
| apply Subtype.ext |
| funext a b |
| change C.val (ListSlot.map (Function.Embedding.refl X) a) |
| (ListSlot.map (Function.Embedding.refl X) b) = C.val a b |
| rw [ListSlot.map_id, ListSlot.map_id] |
|
|
| lemma ListPattern.restrict_comp {s d : ℕ} {X Y Z : Type*} |
| [LinearOrder X] [LinearOrder Y] [LinearOrder Z] (e : X ↪o Y) (f : Y ↪o Z) |
| (C : ListPattern s d Z) : |
| (C.restrict f).restrict e = C.restrict (e.trans f) := by |
| apply Subtype.ext |
| funext a b |
| change C.val (ListSlot.map f.toEmbedding (ListSlot.map e.toEmbedding a)) |
| (ListSlot.map f.toEmbedding (ListSlot.map e.toEmbedding b)) = _ |
| rw [ListSlot.map_comp, ListSlot.map_comp] |
| rfl |
|
|
| noncomputable def ListPattern.extendFin {s d n : ℕ} {X : Type*} [LinearOrder X] |
| (B : Finset X) (h : B.card = n) (C : ListPattern s d (Fin n)) : ListPattern s d X := |
| (C.restrict (B.orderIsoOfFin h).symm.toOrderEmbedding).lift B |
|
|
| lemma ListPattern.restrict_extendFin {s d n : ℕ} {X : Type*} [LinearOrder X] |
| (B : Finset X) (h : B.card = n) (C : ListPattern s d (Fin n)) : |
| (C.extendFin B h).restrict (B.orderEmbOfFin h) = C := by |
| change ((C.restrict (B.orderIsoOfFin h).symm.toOrderEmbedding).lift B).restrict |
| ((B.orderIsoOfFin h).toOrderEmbedding.trans (OrderEmbedding.subtype (· ∈ B))) = C |
| rw [← ListPattern.restrict_comp, ListPattern.restrict_lift, ListPattern.restrict_comp] |
| have he : (B.orderIsoOfFin h).toOrderEmbedding.trans |
| (B.orderIsoOfFin h).symm.toOrderEmbedding = (OrderIso.refl (Fin n)).toOrderEmbedding := by |
| apply DFunLike.ext; intro x; exact (B.orderIsoOfFin h).symm_apply_apply x |
| rw [he, ListPattern.restrict_id] |
|
|
| lemma GloballyAligned.good_full_restrict {s d n : ℕ} (C : ListPattern s d ℚ) |
| (hC : GloballyAligned C) (e : Fin n ↪o ℚ) : |
| GoodPatternOn (C.restrict e) Finset.univ := by |
| classical |
| intro a ha haa |
| obtain ⟨i, hi⟩ := hC (ListSlot.map e.toEmbedding a) haa |
| obtain ⟨j, hj, hji⟩ := Finset.mem_map.mp (hi (ListSlot.map e.toEmbedding a) haa) |
| refine ⟨j, Finset.mem_univ _, ?_⟩ |
| intro b _ hab |
| obtain ⟨k, hk, hki⟩ := Finset.mem_map.mp (hi (ListSlot.map e.toEmbedding b) hab) |
| have hjk : j = k := e.injective (hji.trans hki.symm) |
| exact hjk ▸ hk |
|
|
| lemma isClopen_finite_pattern_event {s d n : ℕ} (E : Set (ListPattern s d (Fin n))) : |
| IsClopen E := isClopen_discrete E |
|
|
| lemma isClopen_bad_restrict {s d n : ℕ} {X : Type*} [LinearOrder X] |
| (e : Fin n ↪o X) : |
| IsClopen {C : ListPattern s d X | ¬GoodPatternOn (C.restrict e) Finset.univ} := |
| (isClopen_finite_pattern_event {D | ¬GoodPatternOn D Finset.univ}).preimage |
| (ListPattern.continuous_restrict e) |
|
|
| lemma ListPattern.measurable_restrict {s d : ℕ} {X Y : Type*} |
| [LinearOrder X] [LinearOrder Y] (e : X ↪o Y) : |
| Measurable (ListPattern.restrict (s := s) (d := d) e) := by |
| apply Measurable.subtype_mk |
| apply Measurable.of_eval; intro a |
| apply Measurable.of_eval; intro b |
| exact (measurable_pi_apply (ListSlot.map e.toEmbedding b)).comp |
| ((measurable_pi_apply (ListSlot.map e.toEmbedding a) : |
| Measurable (fun C : EqualityData s d Y => C (ListSlot.map e.toEmbedding a))).comp |
| measurable_subtype_coe) |
|
|
| noncomputable def restrictionLaw {s d : ℕ} {X Y : Type*} |
| [LinearOrder X] [LinearOrder Y] (e : X ↪o Y) |
| (μ : ProbabilityMeasure (ListPattern s d Y)) : ProbabilityMeasure (ListPattern s d X) := |
| μ.map (ListPattern.restrict e) |
|
|
| lemma restrictionLaw_comp {s d : ℕ} {X Y Z : Type*} |
| [LinearOrder X] [LinearOrder Y] [LinearOrder Z] (e : X ↪o Y) (f : Y ↪o Z) |
| (μ : ProbabilityMeasure (ListPattern s d Z)) : |
| restrictionLaw e (restrictionLaw f μ) = restrictionLaw (e.trans f) μ := by |
| apply ProbabilityMeasure.toMeasure_injective |
| change Measure.map (ListPattern.restrict e) (Measure.map (ListPattern.restrict f) (μ : Measure (ListPattern s d Z))) = _ |
| rw [Measure.map_map (ListPattern.measurable_restrict e) (ListPattern.measurable_restrict f)] |
| congr 1 |
| funext C |
| exact ListPattern.restrict_comp e f C |
|
|
| lemma restrictionLaw_id {s d : ℕ} {X : Type*} [LinearOrder X] |
| (μ : ProbabilityMeasure (ListPattern s d X)) : |
| restrictionLaw (OrderIso.refl X).toOrderEmbedding μ = μ := by |
| apply ProbabilityMeasure.toMeasure_injective |
| change Measure.map _ _ = _ |
| have he : ListPattern.restrict (s := s) (d := d) (OrderIso.refl X).toOrderEmbedding = id := by |
| funext C; exact ListPattern.restrict_id C |
| rw [he, Measure.map_id] |
|
|
| lemma finite_laws_invariant {s d : ℕ} |
| (μ : ProbabilityMeasure (ListPattern s d ℚ)) |
| (h : ∀ n (e f : Fin n ↪o ℚ), restrictionLaw e μ = restrictionLaw f μ) : |
| PatternInvariant (μ : Measure (ListPattern s d ℚ)) := by |
| classical |
| intro g |
| let encode : ListPattern s d ℚ → (ListSlot s d ℚ × ListSlot s d ℚ → Bool) := |
| fun C ab => C.val ab.1 ab.2 |
| have hm : MeasurableEmbedding encode := |
| (MeasurableEquiv.curry (ListSlot s d ℚ) (ListSlot s d ℚ) Bool).symm.measurableEmbedding.comp |
| (MeasurableEmbedding.subtype_coe (isClosed_isPattern s d ℚ).measurableSet) |
| apply hm.map_injective |
| rw [Measure.map_map hm.measurable (ListPattern.measurable_restrict g.toOrderEmbedding)] |
| apply (ProbabilityTheory.map_eq_iff_forall_finset_map_restrict_eq |
| (hm.measurable.comp (ListPattern.measurable_restrict g.toOrderEmbedding)).aemeasurable |
| hm.measurable.aemeasurable).mpr |
| intro J |
| let B : Finset ℚ := J.biUnion (fun ab => ab.1.1.val ∪ ab.2.1.val) |
| have hB (ab : J) : ab.val.1.1.val ⊆ B ∧ ab.val.2.1.val ⊆ B := by |
| constructor |
| · intro x hx |
| exact Finset.mem_biUnion.mpr ⟨ab.val, ab.property, Finset.mem_union_left _ hx⟩ |
| · intro x hx |
| exact Finset.mem_biUnion.mpr ⟨ab.val, ab.property, Finset.mem_union_right _ hx⟩ |
| let e : B ↪o ℚ := OrderEmbedding.subtype (· ∈ B) |
| let u : Fin B.card ≃o B := B.orderIsoOfFin rfl |
| have hfin := h B.card (u.toOrderEmbedding.trans (e.trans g.toOrderEmbedding)) |
| (u.toOrderEmbedding.trans e) |
| have hsub := congrArg (restrictionLaw u.symm.toOrderEmbedding) hfin |
| simp only [restrictionLaw_comp] at hsub |
| have he1 : u.symm.toOrderEmbedding.trans (u.toOrderEmbedding.trans (e.trans g.toOrderEmbedding)) = |
| e.trans g.toOrderEmbedding := by |
| apply DFunLike.ext; intro x; exact congrArg (e.trans g.toOrderEmbedding) (u.apply_symm_apply x) |
| have he2 : u.symm.toOrderEmbedding.trans (u.toOrderEmbedding.trans e) = e := by |
| apply DFunLike.ext; intro x; exact congrArg e (u.apply_symm_apply x) |
| rw [he1, he2] at hsub |
| let F : ListPattern s d B → (J → Bool) := fun C ab => |
| C.val (ab.val.1.inside B (hB ab).1) (ab.val.2.inside B (hB ab).2) |
| have hFm : Measurable F := (continuous_of_discreteTopology : Continuous F).measurable |
| have hmap := congrArg (fun ν : ProbabilityMeasure (ListPattern s d B) => |
| Measure.map F (ν : Measure (ListPattern s d B))) hsub |
| change Measure.map F (Measure.map _ _) = Measure.map F (Measure.map _ _) at hmap |
| rw [Measure.map_map hFm (ListPattern.measurable_restrict _), |
| Measure.map_map hFm (ListPattern.measurable_restrict _)] at hmap |
| convert hmap using 1 <;> congr 1 <;> funext C ab |
| · change C.val (ListSlot.map g.toEmbedding ab.val.1) (ListSlot.map g.toEmbedding ab.val.2) = |
| C.val (ListSlot.map (e.trans g.toOrderEmbedding).toEmbedding |
| (ab.val.1.inside B (hB ab).1)) |
| (ListSlot.map (e.trans g.toOrderEmbedding).toEmbedding (ab.val.2.inside B (hB ab).2)) |
| change C.val (ListSlot.map g.toEmbedding ab.val.1) (ListSlot.map g.toEmbedding ab.val.2) = |
| C.val (ListSlot.map ((Function.Embedding.subtype (· ∈ B)).trans g.toEmbedding) |
| (ab.val.1.inside B (hB ab).1)) |
| (ListSlot.map ((Function.Embedding.subtype (· ∈ B)).trans g.toEmbedding) |
| (ab.val.2.inside B (hB ab).2)) |
| rw [← ListSlot.map_comp, ← ListSlot.map_comp, ListSlot.map_inside, ListSlot.map_inside] |
| · change C.val ab.val.1 ab.val.2 = |
| C.val (ListSlot.map (Function.Embedding.subtype (· ∈ B)) |
| (ab.val.1.inside B (hB ab).1)) |
| (ListSlot.map (Function.Embedding.subtype (· ∈ B)) (ab.val.2.inside B (hB ab).2)) |
| rw [ListSlot.map_inside, ListSlot.map_inside] |
|
|
| open Filter |
| open scoped Topology |
|
|
| instance patternMetrizable (s d : ℕ) (X : Type*) [LinearOrder X] [Countable X] : |
| TopologicalSpace.MetrizableSpace (ListPattern s d X) := by |
| have : TopologicalSpace.MetrizableSpace (EqualityData s d X) := inferInstance |
| exact TopologicalSpace.MetrizableSpace.subtype {C : EqualityData s d X | IsPattern C} |
|
|
| instance patternSecondCountable (s d : ℕ) (X : Type*) [LinearOrder X] [Countable X] : |
| SecondCountableTopology (ListPattern s d X) := by |
| have : SecondCountableTopology (EqualityData s d X) := inferInstance |
| infer_instance |
|
|
| noncomputable instance finitePatternLawMetric (s d n : ℕ) : |
| MetricSpace (ProbabilityMeasure (ListPattern s d (Fin n))) := |
| by |
| have := MeasureTheory.instMetrizableSpaceProbabilityMeasure (ListPattern s d (Fin n)) |
| exact TopologicalSpace.metrizableSpaceMetric _ |
|
|
| lemma continuous_restrictionLaw {s d n : ℕ} (e : Fin n ↪o ℚ) : |
| Continuous (restrictionLaw (s := s) (d := d) e) := |
| ProbabilityMeasure.continuous_map (ListPattern.continuous_restrict e) |
|
|
| theorem no_asymptotically_invariant_bad_sequence {s d : ℕ} {ξ : ℝ} (hξ : 0 < ξ) |
| (seq : ℕ → ProbabilityMeasure (ListPattern s d ℚ)) |
| (hhom : ∀ n (e f : Fin n ↪o ℚ), ∀ᶠ k in atTop, |
| dist (restrictionLaw e (seq k)) (restrictionLaw f (seq k)) ≤ 1 / ((k : ℝ) + 1)) |
| (e₀ : Fin s ↪o ℚ) |
| (hbad : ∀ᶠ k in atTop, |
| ξ ≤ ((seq k) {C | ¬GoodPatternOn (C.restrict e₀) Finset.univ} : ℝ)) : False := by |
| obtain ⟨μ, φ, hφ, hlim⟩ := CompactSpace.tendsto_subseq seq |
| have hinv : PatternInvariant (μ : Measure (ListPattern s d ℚ)) := by |
| apply finite_laws_invariant μ |
| intro n e f |
| have he := (continuous_restrictionLaw e).tendsto μ |>.comp hlim |
| have hf := (continuous_restrictionLaw f).tendsto μ |>.comp hlim |
| have hd := he.dist hf |
| have hz : Tendsto (fun k : ℕ => 1 / ((k : ℝ) + 1)) atTop (𝓝 0) := by |
| exact tendsto_one_div_add_atTop_nhds_zero_nat |
| have hzero : Tendsto (fun k => |
| dist (restrictionLaw e (seq (φ k))) (restrictionLaw f (seq (φ k)))) atTop (𝓝 0) := |
| squeeze_zero' (Eventually.of_forall (fun _ => dist_nonneg)) |
| (hφ.tendsto_atTop.eventually (hhom n e f)) (hz.comp hφ.tendsto_atTop) |
| have hdz : dist (restrictionLaw e μ) (restrictionLaw f μ) = 0 := |
| tendsto_nhds_unique hd hzero |
| exact dist_eq_zero.mp hdz |
| let E : Set (ListPattern s d ℚ) := {C | ¬GoodPatternOn (C.restrict e₀) Finset.univ} |
| have hzero : (μ : Measure (ListPattern s d ℚ)) E = 0 := by |
| apply ae_iff.mp |
| exact (invariant_pattern_globally_aligned _ hinv).mono (fun C hC => |
| hC.good_full_restrict C e₀) |
| have hzero' : μ E = 0 := (μ.null_iff_toMeasure_null E).mpr hzero |
| have hprob := ProbabilityMeasure.tendsto_measure_of_isClopen_of_tendsto hlim |
| (isClopen_bad_restrict e₀) |
| have hreal : Tendsto (fun k => ((seq (φ k)) E : ℝ)) atTop (𝓝 0) := by |
| have hp : Tendsto (fun k => (seq (φ k)) E) atTop (𝓝 (μ E)) := hprob |
| have hh := (NNReal.continuous_coe.tendsto (μ E)).comp hp |
| simpa only [Function.comp_def, hzero', NNReal.coe_zero] using hh |
| have hle : ξ ≤ 0 := ge_of_tendsto hreal (hφ.tendsto_atTop.eventually hbad) |
| exact (not_le_of_gt hξ) hle |
|
|
| end LargeIndependentSets |
|
|
| end OAI |
|
|
