order.filter.countable_Inter ⟷ Mathlib.Order.Filter.CountableInter

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -55,7 +55,7 @@ theorem countable_sInter_mem {S : Set (Set α)} (hSc : S.Countable) : ⋂₀ S 
 
 #print countable_iInter_mem /-
 theorem countable_iInter_mem [Countable ι] {s : ι → Set α} : (⋂ i, s i) ∈ l ↔ ∀ i, s i ∈ l :=
-  sInter_range s ▸ (countable_sInter_mem (countable_range _)).trans forall_range_iff
+  sInter_range s ▸ (countable_sInter_mem (countable_range _)).trans forall_mem_range
 #align countable_Inter_mem countable_iInter_mem
 -/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -173,13 +173,13 @@ def Filter.ofCountableInter (l : Set (Set α))
 #align filter.of_countable_Inter Filter.ofCountableInter
 -/
 
-#print Filter.countable_Inter_ofCountableInter /-
-instance Filter.countable_Inter_ofCountableInter (l : Set (Set α))
+#print Filter.countableInter_ofCountableInter /-
+instance Filter.countableInter_ofCountableInter (l : Set (Set α))
     (hp : ∀ S : Set (Set α), S.Countable → S ⊆ l → ⋂₀ S ∈ l)
     (h_mono : ∀ s t, s ∈ l → s ⊆ t → t ∈ l) :
     CountableInterFilter (Filter.ofCountableInter l hp h_mono) :=
   ⟨hp⟩
-#align filter.countable_Inter_of_countable_Inter Filter.countable_Inter_ofCountableInter
+#align filter.countable_Inter_of_countable_Inter Filter.countableInter_ofCountableInter
 -/
 
 #print Filter.mem_ofCountableInter /-

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -3,8 +3,8 @@ Copyright (c) 2020 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
 -/
-import Mathbin.Order.Filter.Basic
-import Mathbin.Data.Set.Countable
+import Order.Filter.Basic
+import Data.Set.Countable
 
 #align_import order.filter.countable_Inter from "leanprover-community/mathlib"@"b9e46fe101fc897fb2e7edaf0bf1f09ea49eb81a"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

@@ -2,15 +2,12 @@
 Copyright (c) 2020 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
-
-! This file was ported from Lean 3 source module order.filter.countable_Inter
-! leanprover-community/mathlib commit b9e46fe101fc897fb2e7edaf0bf1f09ea49eb81a
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Filter.Basic
 import Mathbin.Data.Set.Countable
 
+#align_import order.filter.countable_Inter from "leanprover-community/mathlib"@"b9e46fe101fc897fb2e7edaf0bf1f09ea49eb81a"
+
 /-!
 # Filters with countable intersection property
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/8b981918a93bc45a8600de608cde7944a80d92b9

@@ -172,7 +172,7 @@ def Filter.ofCountableInter (l : Set (Set α))
   sets_of_superset := h_mono
   inter_sets s t hs ht :=
     sInter_pair s t ▸
-      hp _ ((countable_singleton _).insert _) (insert_subset.2 ⟨hs, singleton_subset_iff.2 ht⟩)
+      hp _ ((countable_singleton _).insert _) (insert_subset_iff.2 ⟨hs, singleton_subset_iff.2 ht⟩)
 #align filter.of_countable_Inter Filter.ofCountableInter
 -/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

@@ -56,9 +56,11 @@ theorem countable_sInter_mem {S : Set (Set α)} (hSc : S.Countable) : ⋂₀ S 
 #align countable_sInter_mem countable_sInter_mem
 -/
 
+#print countable_iInter_mem /-
 theorem countable_iInter_mem [Countable ι] {s : ι → Set α} : (⋂ i, s i) ∈ l ↔ ∀ i, s i ∈ l :=
   sInter_range s ▸ (countable_sInter_mem (countable_range _)).trans forall_range_iff
 #align countable_Inter_mem countable_iInter_mem
+-/
 
 #print countable_bInter_mem /-
 theorem countable_bInter_mem {ι : Type _} {S : Set ι} (hS : S.Countable) {s : ∀ i ∈ S, Set α} :
@@ -70,11 +72,13 @@ theorem countable_bInter_mem {ι : Type _} {S : Set ι} (hS : S.Countable) {s :
 #align countable_bInter_mem countable_bInter_mem
 -/
 
+#print eventually_countable_forall /-
 theorem eventually_countable_forall [Countable ι] {p : α → ι → Prop} :
     (∀ᶠ x in l, ∀ i, p x i) ↔ ∀ i, ∀ᶠ x in l, p x i := by
   simpa only [Filter.Eventually, set_of_forall] using
     @countable_iInter_mem _ _ l _ _ fun i => {x | p x i}
 #align eventually_countable_forall eventually_countable_forall
+-/
 
 #print eventually_countable_ball /-
 theorem eventually_countable_ball {ι : Type _} {S : Set ι} (hS : S.Countable)
@@ -85,16 +89,20 @@ theorem eventually_countable_ball {ι : Type _} {S : Set ι} (hS : S.Countable)
 #align eventually_countable_ball eventually_countable_ball
 -/
 
+#print EventuallyLE.countable_iUnion /-
 theorem EventuallyLE.countable_iUnion [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
     (⋃ i, s i) ≤ᶠ[l] ⋃ i, t i :=
   (eventually_countable_forall.2 h).mono fun x hst hs => mem_iUnion.2 <| (mem_iUnion.1 hs).imp hst
 #align eventually_le.countable_Union EventuallyLE.countable_iUnion
+-/
 
+#print EventuallyEq.countable_iUnion /-
 theorem EventuallyEq.countable_iUnion [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
     (⋃ i, s i) =ᶠ[l] ⋃ i, t i :=
   (EventuallyLE.countable_iUnion fun i => (h i).le).antisymm
     (EventuallyLE.countable_iUnion fun i => (h i).symm.le)
 #align eventually_eq.countable_Union EventuallyEq.countable_iUnion
+-/
 
 #print EventuallyLE.countable_bUnion /-
 theorem EventuallyLE.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countable)
@@ -116,17 +124,21 @@ theorem EventuallyEq.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countab
 #align eventually_eq.countable_bUnion EventuallyEq.countable_bUnion
 -/
 
+#print EventuallyLE.countable_iInter /-
 theorem EventuallyLE.countable_iInter [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
     (⋂ i, s i) ≤ᶠ[l] ⋂ i, t i :=
   (eventually_countable_forall.2 h).mono fun x hst hs =>
     mem_iInter.2 fun i => hst _ (mem_iInter.1 hs i)
 #align eventually_le.countable_Inter EventuallyLE.countable_iInter
+-/
 
+#print EventuallyEq.countable_iInter /-
 theorem EventuallyEq.countable_iInter [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
     (⋂ i, s i) =ᶠ[l] ⋂ i, t i :=
   (EventuallyLE.countable_iInter fun i => (h i).le).antisymm
     (EventuallyLE.countable_iInter fun i => (h i).symm.le)
 #align eventually_eq.countable_Inter EventuallyEq.countable_iInter
+-/
 
 #print EventuallyLE.countable_bInter /-
 theorem EventuallyLE.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countable)
@@ -188,13 +200,17 @@ instance countableInterFilter_principal (s : Set α) : CountableInterFilter (
 #align countable_Inter_filter_principal countableInterFilter_principal
 -/
 
+#print countableInterFilter_bot /-
 instance countableInterFilter_bot : CountableInterFilter (⊥ : Filter α) := by
   rw [← principal_empty]; apply countableInterFilter_principal
 #align countable_Inter_filter_bot countableInterFilter_bot
+-/
 
+#print countableInterFilter_top /-
 instance countableInterFilter_top : CountableInterFilter (⊤ : Filter α) := by rw [← principal_univ];
   apply countableInterFilter_principal
 #align countable_Inter_filter_top countableInterFilter_top
+-/
 
 instance (l : Filter β) [CountableInterFilter l] (f : α → β) : CountableInterFilter (comap f l) :=
   by
@@ -210,6 +226,7 @@ instance (l : Filter α) [CountableInterFilter l] (f : α → β) : CountableInt
   simp only [mem_map, sInter_eq_bInter, preimage_Inter₂] at hS ⊢
   exact (countable_bInter_mem hSc).2 hS
 
+#print countableInterFilter_inf /-
 /-- Infimum of two `countable_Inter_filter`s is a `countable_Inter_filter`. This is useful, e.g.,
 to automatically get an instance for `residual α ⊓ 𝓟 s`. -/
 instance countableInterFilter_inf (l₁ l₂ : Filter α) [CountableInterFilter l₁]
@@ -223,7 +240,9 @@ instance countableInterFilter_inf (l₁ l₂ : Filter α) [CountableInterFilter
   rw [hst i hi]
   apply inter_subset_inter <;> exact Inter_subset_of_subset i (Inter_subset _ _)
 #align countable_Inter_filter_inf countableInterFilter_inf
+-/
 
+#print countableInterFilter_sup /-
 /-- Supremum of two `countable_Inter_filter`s is a `countable_Inter_filter`. -/
 instance countableInterFilter_sup (l₁ l₂ : Filter α) [CountableInterFilter l₁]
     [CountableInterFilter l₂] : CountableInterFilter (l₁ ⊔ l₂) :=
@@ -231,6 +250,7 @@ instance countableInterFilter_sup (l₁ l₂ : Filter α) [CountableInterFilter
   refine' ⟨fun S hSc hS => ⟨_, _⟩⟩ <;> refine' (countable_sInter_mem hSc).2 fun s hs => _
   exacts [(hS s hs).1, (hS s hs).2]
 #align countable_Inter_filter_sup countableInterFilter_sup
+-/
 
 namespace Filter
 
@@ -284,6 +304,7 @@ theorem mem_countableGenerate_iff {s : Set α} :
 #align filter.mem_countable_generate_iff Filter.mem_countableGenerate_iff
 -/
 
+#print Filter.le_countableGenerate_iff_of_countableInterFilter /-
 theorem le_countableGenerate_iff_of_countableInterFilter {f : Filter α} [CountableInterFilter f] :
     f ≤ countableGenerate g ↔ g ⊆ f.sets :=
   by
@@ -296,9 +317,11 @@ theorem le_countableGenerate_iff_of_countableInterFilter {f : Filter α} [Counta
   · exact mem_of_superset ih st
   exact (countable_sInter_mem Sct).mpr ih
 #align filter.le_countable_generate_iff_of_countable_Inter_filter Filter.le_countableGenerate_iff_of_countableInterFilter
+-/
 
 variable (g)
 
+#print Filter.countableGenerate_isGreatest /-
 /-- `countable_generate g` is the greatest `countable_Inter_filter` containing `g`.-/
 theorem countableGenerate_isGreatest :
     IsGreatest {f : Filter α | CountableInterFilter f ∧ g ⊆ f.sets} (countableGenerate g) :=
@@ -307,6 +330,7 @@ theorem countableGenerate_isGreatest :
   rintro f ⟨fct, hf⟩
   rwa [@le_countable_generate_iff_of_countable_Inter_filter _ _ _ fct]
 #align filter.countable_generate_is_greatest Filter.countableGenerate_isGreatest
+-/
 
 end Filter
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

@@ -73,7 +73,7 @@ theorem countable_bInter_mem {ι : Type _} {S : Set ι} (hS : S.Countable) {s :
 theorem eventually_countable_forall [Countable ι] {p : α → ι → Prop} :
     (∀ᶠ x in l, ∀ i, p x i) ↔ ∀ i, ∀ᶠ x in l, p x i := by
   simpa only [Filter.Eventually, set_of_forall] using
-    @countable_iInter_mem _ _ l _ _ fun i => { x | p x i }
+    @countable_iInter_mem _ _ l _ _ fun i => {x | p x i}
 #align eventually_countable_forall eventually_countable_forall
 
 #print eventually_countable_ball /-
@@ -81,7 +81,7 @@ theorem eventually_countable_ball {ι : Type _} {S : Set ι} (hS : S.Countable)
     {p : ∀ (x : α), ∀ i ∈ S, Prop} :
     (∀ᶠ x in l, ∀ i ∈ S, p x i ‹_›) ↔ ∀ i ∈ S, ∀ᶠ x in l, p x i ‹_› := by
   simpa only [Filter.Eventually, set_of_forall] using
-    @countable_bInter_mem _ l _ _ _ hS fun i hi => { x | p x i hi }
+    @countable_bInter_mem _ l _ _ _ hS fun i hi => {x | p x i hi}
 #align eventually_countable_ball eventually_countable_ball
 -/
 
@@ -301,7 +301,7 @@ variable (g)
 
 /-- `countable_generate g` is the greatest `countable_Inter_filter` containing `g`.-/
 theorem countableGenerate_isGreatest :
-    IsGreatest { f : Filter α | CountableInterFilter f ∧ g ⊆ f.sets } (countableGenerate g) :=
+    IsGreatest {f : Filter α | CountableInterFilter f ∧ g ⊆ f.sets} (countableGenerate g) :=
   by
   refine' ⟨⟨inferInstance, fun s => countable_generate_sets.basic⟩, _⟩
   rintro f ⟨fct, hf⟩

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

@@ -207,7 +207,7 @@ instance (l : Filter β) [CountableInterFilter l] (f : α → β) : CountableInt
 instance (l : Filter α) [CountableInterFilter l] (f : α → β) : CountableInterFilter (map f l) :=
   by
   constructor; intro S hSc hS
-  simp only [mem_map, sInter_eq_bInter, preimage_Inter₂] at hS⊢
+  simp only [mem_map, sInter_eq_bInter, preimage_Inter₂] at hS ⊢
   exact (countable_bInter_mem hSc).2 hS
 
 /-- Infimum of two `countable_Inter_filter`s is a `countable_Inter_filter`. This is useful, e.g.,
@@ -229,7 +229,7 @@ instance countableInterFilter_sup (l₁ l₂ : Filter α) [CountableInterFilter
     [CountableInterFilter l₂] : CountableInterFilter (l₁ ⊔ l₂) :=
   by
   refine' ⟨fun S hSc hS => ⟨_, _⟩⟩ <;> refine' (countable_sInter_mem hSc).2 fun s hs => _
-  exacts[(hS s hs).1, (hS s hs).2]
+  exacts [(hS s hs).1, (hS s hs).2]
 #align countable_Inter_filter_sup countableInterFilter_sup
 
 namespace Filter
@@ -253,8 +253,8 @@ inductive CountableGenerateSets : Set α → Prop
 /-- `filter.countable_generate g` is the greatest `countable_Inter_filter` containing `g`.-/
 def countableGenerate : Filter α :=
   ofCountableInter (CountableGenerateSets g) (fun S => CountableGenerateSets.sInter) fun s t =>
-    CountableGenerateSets.superset deriving
-  CountableInterFilter
+    CountableGenerateSets.superset
+deriving CountableInterFilter
 #align filter.countable_generate Filter.countableGenerate
 -/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -35,7 +35,7 @@ filter, countable
 
 open Set Filter
 
-open Filter
+open scoped Filter
 
 variable {ι : Sort _} {α β : Type _}
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -56,12 +56,6 @@ theorem countable_sInter_mem {S : Set (Set α)} (hSc : S.Countable) : ⋂₀ S 
 #align countable_sInter_mem countable_sInter_mem
 -/
 
-/- warning: countable_Inter_mem -> countable_iInter_mem is a dubious translation:
-lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)}, Iff (Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) (Set.iInter.{u2, u1} α ι (fun (i : ι) => s i)) l) (forall (i : ι), Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) (s i) l)
-but is expected to have type
-  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (Set.iInter.{u1, u2} α ι (fun (i : ι) => s i)) l) (forall (i : ι), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (s i) l)
-Case conversion may be inaccurate. Consider using '#align countable_Inter_mem countable_iInter_memₓ'. -/
 theorem countable_iInter_mem [Countable ι] {s : ι → Set α} : (⋂ i, s i) ∈ l ↔ ∀ i, s i ∈ l :=
   sInter_range s ▸ (countable_sInter_mem (countable_range _)).trans forall_range_iff
 #align countable_Inter_mem countable_iInter_mem
@@ -76,12 +70,6 @@ theorem countable_bInter_mem {ι : Type _} {S : Set ι} (hS : S.Countable) {s :
 #align countable_bInter_mem countable_bInter_mem
 -/
 
-/- warning: eventually_countable_forall -> eventually_countable_forall is a dubious translation:
-lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {p : α -> ι -> Prop}, Iff (Filter.Eventually.{u2} α (fun (x : α) => forall (i : ι), p x i) l) (forall (i : ι), Filter.Eventually.{u2} α (fun (x : α) => p x i) l)
-but is expected to have type
-  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {p : α -> ι -> Prop}, Iff (Filter.Eventually.{u1} α (fun (x : α) => forall (i : ι), p x i) l) (forall (i : ι), Filter.Eventually.{u1} α (fun (x : α) => p x i) l)
-Case conversion may be inaccurate. Consider using '#align eventually_countable_forall eventually_countable_forallₓ'. -/
 theorem eventually_countable_forall [Countable ι] {p : α → ι → Prop} :
     (∀ᶠ x in l, ∀ i, p x i) ↔ ∀ i, ∀ᶠ x in l, p x i := by
   simpa only [Filter.Eventually, set_of_forall] using
@@ -97,23 +85,11 @@ theorem eventually_countable_ball {ι : Type _} {S : Set ι} (hS : S.Countable)
 #align eventually_countable_ball eventually_countable_ball
 -/
 
-/- warning: eventually_le.countable_Union -> EventuallyLE.countable_iUnion is a dubious translation:
-lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)} {t : ι -> (Set.{u2} α)}, (forall (i : ι), Filter.EventuallyLE.{u2, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLE.{u2, 0} α Prop Prop.le l (Set.iUnion.{u2, u1} α ι (fun (i : ι) => s i)) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => t i)))
-but is expected to have type
-  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)} {t : ι -> (Set.{u1} α)}, (forall (i : ι), Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (Set.iUnion.{u1, u2} α ι (fun (i : ι) => s i)) (Set.iUnion.{u1, u2} α ι (fun (i : ι) => t i)))
-Case conversion may be inaccurate. Consider using '#align eventually_le.countable_Union EventuallyLE.countable_iUnionₓ'. -/
 theorem EventuallyLE.countable_iUnion [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
     (⋃ i, s i) ≤ᶠ[l] ⋃ i, t i :=
   (eventually_countable_forall.2 h).mono fun x hst hs => mem_iUnion.2 <| (mem_iUnion.1 hs).imp hst
 #align eventually_le.countable_Union EventuallyLE.countable_iUnion
 
-/- warning: eventually_eq.countable_Union -> EventuallyEq.countable_iUnion is a dubious translation:
-lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)} {t : ι -> (Set.{u2} α)}, (forall (i : ι), Filter.EventuallyEq.{u2, 0} α Prop l (s i) (t i)) -> (Filter.EventuallyEq.{u2, 0} α Prop l (Set.iUnion.{u2, u1} α ι (fun (i : ι) => s i)) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => t i)))
-but is expected to have type
-  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)} {t : ι -> (Set.{u1} α)}, (forall (i : ι), Filter.EventuallyEq.{u1, 0} α Prop l (s i) (t i)) -> (Filter.EventuallyEq.{u1, 0} α Prop l (Set.iUnion.{u1, u2} α ι (fun (i : ι) => s i)) (Set.iUnion.{u1, u2} α ι (fun (i : ι) => t i)))
-Case conversion may be inaccurate. Consider using '#align eventually_eq.countable_Union EventuallyEq.countable_iUnionₓ'. -/
 theorem EventuallyEq.countable_iUnion [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
     (⋃ i, s i) =ᶠ[l] ⋃ i, t i :=
   (EventuallyLE.countable_iUnion fun i => (h i).le).antisymm
@@ -140,24 +116,12 @@ theorem EventuallyEq.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countab
 #align eventually_eq.countable_bUnion EventuallyEq.countable_bUnion
 -/
 
-/- warning: eventually_le.countable_Inter -> EventuallyLE.countable_iInter is a dubious translation:
-lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)} {t : ι -> (Set.{u2} α)}, (forall (i : ι), Filter.EventuallyLE.{u2, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLE.{u2, 0} α Prop Prop.le l (Set.iInter.{u2, u1} α ι (fun (i : ι) => s i)) (Set.iInter.{u2, u1} α ι (fun (i : ι) => t i)))
-but is expected to have type
-  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)} {t : ι -> (Set.{u1} α)}, (forall (i : ι), Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (Set.iInter.{u1, u2} α ι (fun (i : ι) => s i)) (Set.iInter.{u1, u2} α ι (fun (i : ι) => t i)))
-Case conversion may be inaccurate. Consider using '#align eventually_le.countable_Inter EventuallyLE.countable_iInterₓ'. -/
 theorem EventuallyLE.countable_iInter [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
     (⋂ i, s i) ≤ᶠ[l] ⋂ i, t i :=
   (eventually_countable_forall.2 h).mono fun x hst hs =>
     mem_iInter.2 fun i => hst _ (mem_iInter.1 hs i)
 #align eventually_le.countable_Inter EventuallyLE.countable_iInter
 
-/- warning: eventually_eq.countable_Inter -> EventuallyEq.countable_iInter is a dubious translation:
-lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)} {t : ι -> (Set.{u2} α)}, (forall (i : ι), Filter.EventuallyEq.{u2, 0} α Prop l (s i) (t i)) -> (Filter.EventuallyEq.{u2, 0} α Prop l (Set.iInter.{u2, u1} α ι (fun (i : ι) => s i)) (Set.iInter.{u2, u1} α ι (fun (i : ι) => t i)))
-but is expected to have type
-  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)} {t : ι -> (Set.{u1} α)}, (forall (i : ι), Filter.EventuallyEq.{u1, 0} α Prop l (s i) (t i)) -> (Filter.EventuallyEq.{u1, 0} α Prop l (Set.iInter.{u1, u2} α ι (fun (i : ι) => s i)) (Set.iInter.{u1, u2} α ι (fun (i : ι) => t i)))
-Case conversion may be inaccurate. Consider using '#align eventually_eq.countable_Inter EventuallyEq.countable_iInterₓ'. -/
 theorem EventuallyEq.countable_iInter [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
     (⋂ i, s i) =ᶠ[l] ⋂ i, t i :=
   (EventuallyLE.countable_iInter fun i => (h i).le).antisymm
@@ -224,22 +188,10 @@ instance countableInterFilter_principal (s : Set α) : CountableInterFilter (
 #align countable_Inter_filter_principal countableInterFilter_principal
 -/
 
-/- warning: countable_Inter_filter_bot -> countableInterFilter_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, CountableInterFilter.{u1} α (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}}, CountableInterFilter.{u1} α (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align countable_Inter_filter_bot countableInterFilter_botₓ'. -/
 instance countableInterFilter_bot : CountableInterFilter (⊥ : Filter α) := by
   rw [← principal_empty]; apply countableInterFilter_principal
 #align countable_Inter_filter_bot countableInterFilter_bot
 
-/- warning: countable_Inter_filter_top -> countableInterFilter_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, CountableInterFilter.{u1} α (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}}, CountableInterFilter.{u1} α (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))
-Case conversion may be inaccurate. Consider using '#align countable_Inter_filter_top countableInterFilter_topₓ'. -/
 instance countableInterFilter_top : CountableInterFilter (⊤ : Filter α) := by rw [← principal_univ];
   apply countableInterFilter_principal
 #align countable_Inter_filter_top countableInterFilter_top
@@ -258,12 +210,6 @@ instance (l : Filter α) [CountableInterFilter l] (f : α → β) : CountableInt
   simp only [mem_map, sInter_eq_bInter, preimage_Inter₂] at hS⊢
   exact (countable_bInter_mem hSc).2 hS
 
-/- warning: countable_Inter_filter_inf -> countableInterFilter_inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (l₁ : Filter.{u1} α) (l₂ : Filter.{u1} α) [_inst_2 : CountableInterFilter.{u1} α l₁] [_inst_3 : CountableInterFilter.{u1} α l₂], CountableInterFilter.{u1} α (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l₁ l₂)
-but is expected to have type
-  forall {α : Type.{u1}} (l₁ : Filter.{u1} α) (l₂ : Filter.{u1} α) [_inst_2 : CountableInterFilter.{u1} α l₁] [_inst_3 : CountableInterFilter.{u1} α l₂], CountableInterFilter.{u1} α (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l₁ l₂)
-Case conversion may be inaccurate. Consider using '#align countable_Inter_filter_inf countableInterFilter_infₓ'. -/
 /-- Infimum of two `countable_Inter_filter`s is a `countable_Inter_filter`. This is useful, e.g.,
 to automatically get an instance for `residual α ⊓ 𝓟 s`. -/
 instance countableInterFilter_inf (l₁ l₂ : Filter α) [CountableInterFilter l₁]
@@ -278,12 +224,6 @@ instance countableInterFilter_inf (l₁ l₂ : Filter α) [CountableInterFilter
   apply inter_subset_inter <;> exact Inter_subset_of_subset i (Inter_subset _ _)
 #align countable_Inter_filter_inf countableInterFilter_inf
 
-/- warning: countable_Inter_filter_sup -> countableInterFilter_sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (l₁ : Filter.{u1} α) (l₂ : Filter.{u1} α) [_inst_2 : CountableInterFilter.{u1} α l₁] [_inst_3 : CountableInterFilter.{u1} α l₂], CountableInterFilter.{u1} α (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) l₁ l₂)
-but is expected to have type
-  forall {α : Type.{u1}} (l₁ : Filter.{u1} α) (l₂ : Filter.{u1} α) [_inst_2 : CountableInterFilter.{u1} α l₁] [_inst_3 : CountableInterFilter.{u1} α l₂], CountableInterFilter.{u1} α (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) l₁ l₂)
-Case conversion may be inaccurate. Consider using '#align countable_Inter_filter_sup countableInterFilter_supₓ'. -/
 /-- Supremum of two `countable_Inter_filter`s is a `countable_Inter_filter`. -/
 instance countableInterFilter_sup (l₁ l₂ : Filter α) [CountableInterFilter l₁]
     [CountableInterFilter l₂] : CountableInterFilter (l₁ ⊔ l₂) :=
@@ -344,12 +284,6 @@ theorem mem_countableGenerate_iff {s : Set α} :
 #align filter.mem_countable_generate_iff Filter.mem_countableGenerate_iff
 -/
 
-/- warning: filter.le_countable_generate_iff_of_countable_Inter_filter -> Filter.le_countableGenerate_iff_of_countableInterFilter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {g : Set.{u1} (Set.{u1} α)} {f : Filter.{u1} α} [_inst_2 : CountableInterFilter.{u1} α f], Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Filter.countableGenerate.{u1} α g)) (HasSubset.Subset.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasSubset.{u1} (Set.{u1} α)) g (Filter.sets.{u1} α f))
-but is expected to have type
-  forall {α : Type.{u1}} {g : Set.{u1} (Set.{u1} α)} {f : Filter.{u1} α} [_inst_2 : CountableInterFilter.{u1} α f], Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (Filter.countableGenerate.{u1} α g)) (HasSubset.Subset.{u1} (Set.{u1} (Set.{u1} α)) (Set.instHasSubsetSet.{u1} (Set.{u1} α)) g (Filter.sets.{u1} α f))
-Case conversion may be inaccurate. Consider using '#align filter.le_countable_generate_iff_of_countable_Inter_filter Filter.le_countableGenerate_iff_of_countableInterFilterₓ'. -/
 theorem le_countableGenerate_iff_of_countableInterFilter {f : Filter α} [CountableInterFilter f] :
     f ≤ countableGenerate g ↔ g ⊆ f.sets :=
   by
@@ -365,12 +299,6 @@ theorem le_countableGenerate_iff_of_countableInterFilter {f : Filter α} [Counta
 
 variable (g)
 
-/- warning: filter.countable_generate_is_greatest -> Filter.countableGenerate_isGreatest is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (g : Set.{u1} (Set.{u1} α)), IsGreatest.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)) (setOf.{u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => And (CountableInterFilter.{u1} α f) (HasSubset.Subset.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasSubset.{u1} (Set.{u1} α)) g (Filter.sets.{u1} α f)))) (Filter.countableGenerate.{u1} α g)
-but is expected to have type
-  forall {α : Type.{u1}} (g : Set.{u1} (Set.{u1} α)), IsGreatest.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α)) (setOf.{u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => And (CountableInterFilter.{u1} α f) (HasSubset.Subset.{u1} (Set.{u1} (Set.{u1} α)) (Set.instHasSubsetSet.{u1} (Set.{u1} α)) g (Filter.sets.{u1} α f)))) (Filter.countableGenerate.{u1} α g)
-Case conversion may be inaccurate. Consider using '#align filter.countable_generate_is_greatest Filter.countableGenerate_isGreatestₓ'. -/
 /-- `countable_generate g` is the greatest `countable_Inter_filter` containing `g`.-/
 theorem countableGenerate_isGreatest :
     IsGreatest { f : Filter α | CountableInterFilter f ∧ g ⊆ f.sets } (countableGenerate g) :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -230,10 +230,8 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}}, CountableInterFilter.{u1} α (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))
 Case conversion may be inaccurate. Consider using '#align countable_Inter_filter_bot countableInterFilter_botₓ'. -/
-instance countableInterFilter_bot : CountableInterFilter (⊥ : Filter α) :=
-  by
-  rw [← principal_empty]
-  apply countableInterFilter_principal
+instance countableInterFilter_bot : CountableInterFilter (⊥ : Filter α) := by
+  rw [← principal_empty]; apply countableInterFilter_principal
 #align countable_Inter_filter_bot countableInterFilter_bot
 
 /- warning: countable_Inter_filter_top -> countableInterFilter_top is a dubious translation:
@@ -242,9 +240,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}}, CountableInterFilter.{u1} α (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))
 Case conversion may be inaccurate. Consider using '#align countable_Inter_filter_top countableInterFilter_topₓ'. -/
-instance countableInterFilter_top : CountableInterFilter (⊤ : Filter α) :=
-  by
-  rw [← principal_univ]
+instance countableInterFilter_top : CountableInterFilter (⊤ : Filter α) := by rw [← principal_univ];
   apply countableInterFilter_principal
 #align countable_Inter_filter_top countableInterFilter_top
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/75e7fca56381d056096ce5d05e938f63a6567828

@@ -300,6 +300,7 @@ namespace Filter
 
 variable (g : Set (Set α))
 
+#print Filter.CountableGenerateSets /-
 /-- `filter.countable_generate_sets g` is the (sets of the)
 greatest `countable_Inter_filter` containing `g`.-/
 inductive CountableGenerateSets : Set α → Prop
@@ -310,16 +311,20 @@ inductive CountableGenerateSets : Set α → Prop
   Inter {S : Set (Set α)} :
     S.Countable → (∀ s ∈ S, countable_generate_sets s) → countable_generate_sets (⋂₀ S)
 #align filter.countable_generate_sets Filter.CountableGenerateSets
+-/
 
+#print Filter.countableGenerate /-
 /-- `filter.countable_generate g` is the greatest `countable_Inter_filter` containing `g`.-/
 def countableGenerate : Filter α :=
-  ofCountableInter (CountableGenerateSets g) (fun S => CountableGenerateSets.Inter) fun s t =>
+  ofCountableInter (CountableGenerateSets g) (fun S => CountableGenerateSets.sInter) fun s t =>
     CountableGenerateSets.superset deriving
   CountableInterFilter
 #align filter.countable_generate Filter.countableGenerate
+-/
 
 variable {g}
 
+#print Filter.mem_countableGenerate_iff /-
 /-- A set is in the `countable_Inter_filter` generated by `g` if and only if
 it contains a countable intersection of elements of `g`. -/
 theorem mem_countableGenerate_iff {s : Set α} :
@@ -341,7 +346,14 @@ theorem mem_countableGenerate_iff {s : Set α} :
   intro s H
   exact countable_generate_sets.basic (Sg H)
 #align filter.mem_countable_generate_iff Filter.mem_countableGenerate_iff
+-/
 
+/- warning: filter.le_countable_generate_iff_of_countable_Inter_filter -> Filter.le_countableGenerate_iff_of_countableInterFilter is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {g : Set.{u1} (Set.{u1} α)} {f : Filter.{u1} α} [_inst_2 : CountableInterFilter.{u1} α f], Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Filter.countableGenerate.{u1} α g)) (HasSubset.Subset.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasSubset.{u1} (Set.{u1} α)) g (Filter.sets.{u1} α f))
+but is expected to have type
+  forall {α : Type.{u1}} {g : Set.{u1} (Set.{u1} α)} {f : Filter.{u1} α} [_inst_2 : CountableInterFilter.{u1} α f], Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (Filter.countableGenerate.{u1} α g)) (HasSubset.Subset.{u1} (Set.{u1} (Set.{u1} α)) (Set.instHasSubsetSet.{u1} (Set.{u1} α)) g (Filter.sets.{u1} α f))
+Case conversion may be inaccurate. Consider using '#align filter.le_countable_generate_iff_of_countable_Inter_filter Filter.le_countableGenerate_iff_of_countableInterFilterₓ'. -/
 theorem le_countableGenerate_iff_of_countableInterFilter {f : Filter α} [CountableInterFilter f] :
     f ≤ countableGenerate g ↔ g ⊆ f.sets :=
   by
@@ -357,6 +369,12 @@ theorem le_countableGenerate_iff_of_countableInterFilter {f : Filter α} [Counta
 
 variable (g)
 
+/- warning: filter.countable_generate_is_greatest -> Filter.countableGenerate_isGreatest is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} (g : Set.{u1} (Set.{u1} α)), IsGreatest.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)) (setOf.{u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => And (CountableInterFilter.{u1} α f) (HasSubset.Subset.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasSubset.{u1} (Set.{u1} α)) g (Filter.sets.{u1} α f)))) (Filter.countableGenerate.{u1} α g)
+but is expected to have type
+  forall {α : Type.{u1}} (g : Set.{u1} (Set.{u1} α)), IsGreatest.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α)) (setOf.{u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => And (CountableInterFilter.{u1} α f) (HasSubset.Subset.{u1} (Set.{u1} (Set.{u1} α)) (Set.instHasSubsetSet.{u1} (Set.{u1} α)) g (Filter.sets.{u1} α f)))) (Filter.countableGenerate.{u1} α g)
+Case conversion may be inaccurate. Consider using '#align filter.countable_generate_is_greatest Filter.countableGenerate_isGreatestₓ'. -/
 /-- `countable_generate g` is the greatest `countable_Inter_filter` containing `g`.-/
 theorem countableGenerate_isGreatest :
     IsGreatest { f : Filter α | CountableInterFilter f ∧ g ⊆ f.sets } (countableGenerate g) :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/33c67ae661dd8988516ff7f247b0be3018cdd952

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
 
 ! This file was ported from Lean 3 source module order.filter.countable_Inter
-! leanprover-community/mathlib commit 4d392a6c9c4539cbeca399b3ee0afea398fbd2eb
+! leanprover-community/mathlib commit b9e46fe101fc897fb2e7edaf0bf1f09ea49eb81a
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -20,7 +20,7 @@ import Mathbin.Data.Set.Countable
 In this file we define `countable_Inter_filter` to be the class of filters with the following
 property: for any countable collection of sets `s ∈ l` their intersection belongs to `l` as well.
 
-Two main examples are the `residual` filter defined in `topology.metric_space.baire` and
+Two main examples are the `residual` filter defined in `topology.G_delta` and
 the `measure.ae` filter defined in `measure_theory.measure_space`.
 
 We reformulate the definition in terms of indexed intersection and in terms of `filter.eventually`
@@ -296,3 +296,75 @@ instance countableInterFilter_sup (l₁ l₂ : Filter α) [CountableInterFilter
   exacts[(hS s hs).1, (hS s hs).2]
 #align countable_Inter_filter_sup countableInterFilter_sup
 
+namespace Filter
+
+variable (g : Set (Set α))
+
+/-- `filter.countable_generate_sets g` is the (sets of the)
+greatest `countable_Inter_filter` containing `g`.-/
+inductive CountableGenerateSets : Set α → Prop
+  | basic {s : Set α} : s ∈ g → countable_generate_sets s
+  | univ : countable_generate_sets univ
+  | Superset {s t : Set α} : countable_generate_sets s → s ⊆ t → countable_generate_sets t
+  |
+  Inter {S : Set (Set α)} :
+    S.Countable → (∀ s ∈ S, countable_generate_sets s) → countable_generate_sets (⋂₀ S)
+#align filter.countable_generate_sets Filter.CountableGenerateSets
+
+/-- `filter.countable_generate g` is the greatest `countable_Inter_filter` containing `g`.-/
+def countableGenerate : Filter α :=
+  ofCountableInter (CountableGenerateSets g) (fun S => CountableGenerateSets.Inter) fun s t =>
+    CountableGenerateSets.superset deriving
+  CountableInterFilter
+#align filter.countable_generate Filter.countableGenerate
+
+variable {g}
+
+/-- A set is in the `countable_Inter_filter` generated by `g` if and only if
+it contains a countable intersection of elements of `g`. -/
+theorem mem_countableGenerate_iff {s : Set α} :
+    s ∈ countableGenerate g ↔ ∃ S : Set (Set α), S ⊆ g ∧ S.Countable ∧ ⋂₀ S ⊆ s :=
+  by
+  constructor <;> intro h
+  · induction' h with s hs s t hs st ih S Sct hS ih
+    · exact ⟨{s}, by simp [hs]⟩
+    · exact ⟨∅, by simp⟩
+    · refine' Exists.imp (fun S => _) ih
+      tauto
+    choose T Tg Tct hT using ih
+    refine' ⟨⋃ (s) (H : s ∈ S), T s H, by simpa, Sct.bUnion Tct, _⟩
+    apply subset_sInter
+    intro s H
+    refine' subset_trans (sInter_subset_sInter (subset_Union₂ s H)) (hT s H)
+  rcases h with ⟨S, Sg, Sct, hS⟩
+  refine' mem_of_superset ((countable_sInter_mem Sct).mpr _) hS
+  intro s H
+  exact countable_generate_sets.basic (Sg H)
+#align filter.mem_countable_generate_iff Filter.mem_countableGenerate_iff
+
+theorem le_countableGenerate_iff_of_countableInterFilter {f : Filter α} [CountableInterFilter f] :
+    f ≤ countableGenerate g ↔ g ⊆ f.sets :=
+  by
+  constructor <;> intro h
+  · exact subset_trans (fun s => countable_generate_sets.basic) h
+  intro s hs
+  induction' hs with s hs s t hs st ih S Sct hS ih
+  · exact h hs
+  · exact univ_mem
+  · exact mem_of_superset ih st
+  exact (countable_sInter_mem Sct).mpr ih
+#align filter.le_countable_generate_iff_of_countable_Inter_filter Filter.le_countableGenerate_iff_of_countableInterFilter
+
+variable (g)
+
+/-- `countable_generate g` is the greatest `countable_Inter_filter` containing `g`.-/
+theorem countableGenerate_isGreatest :
+    IsGreatest { f : Filter α | CountableInterFilter f ∧ g ⊆ f.sets } (countableGenerate g) :=
+  by
+  refine' ⟨⟨inferInstance, fun s => countable_generate_sets.basic⟩, _⟩
+  rintro f ⟨fct, hf⟩
+  rwa [@le_countable_generate_iff_of_countable_Inter_filter _ _ _ fct]
+#align filter.countable_generate_is_greatest Filter.countableGenerate_isGreatest
+
+end Filter
+

mathlib commit https://github.com/leanprover-community/mathlib/commit/e3fb84046afd187b710170887195d50bada934ee

@@ -43,28 +43,28 @@ variable {ι : Sort _} {α β : Type _}
 /-- A filter `l` has the countable intersection property if for any countable collection
 of sets `s ∈ l` their intersection belongs to `l` as well. -/
 class CountableInterFilter (l : Filter α) : Prop where
-  countable_interₛ_mem' : ∀ {S : Set (Set α)} (hSc : S.Countable) (hS : ∀ s ∈ S, s ∈ l), ⋂₀ S ∈ l
+  countable_sInter_mem' : ∀ {S : Set (Set α)} (hSc : S.Countable) (hS : ∀ s ∈ S, s ∈ l), ⋂₀ S ∈ l
 #align countable_Inter_filter CountableInterFilter
 -/
 
 variable {l : Filter α} [CountableInterFilter l]
 
-#print countable_interₛ_mem /-
-theorem countable_interₛ_mem {S : Set (Set α)} (hSc : S.Countable) : ⋂₀ S ∈ l ↔ ∀ s ∈ S, s ∈ l :=
-  ⟨fun hS s hs => mem_of_superset hS (interₛ_subset_of_mem hs),
-    CountableInterFilter.countable_interₛ_mem' hSc⟩
-#align countable_sInter_mem countable_interₛ_mem
+#print countable_sInter_mem /-
+theorem countable_sInter_mem {S : Set (Set α)} (hSc : S.Countable) : ⋂₀ S ∈ l ↔ ∀ s ∈ S, s ∈ l :=
+  ⟨fun hS s hs => mem_of_superset hS (sInter_subset_of_mem hs),
+    CountableInterFilter.countable_sInter_mem' hSc⟩
+#align countable_sInter_mem countable_sInter_mem
 -/
 
-/- warning: countable_Inter_mem -> countable_interᵢ_mem is a dubious translation:
+/- warning: countable_Inter_mem -> countable_iInter_mem is a dubious translation:
 lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)}, Iff (Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) (Set.interᵢ.{u2, u1} α ι (fun (i : ι) => s i)) l) (forall (i : ι), Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) (s i) l)
+  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)}, Iff (Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) (Set.iInter.{u2, u1} α ι (fun (i : ι) => s i)) l) (forall (i : ι), Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) (s i) l)
 but is expected to have type
-  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (Set.interᵢ.{u1, u2} α ι (fun (i : ι) => s i)) l) (forall (i : ι), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (s i) l)
-Case conversion may be inaccurate. Consider using '#align countable_Inter_mem countable_interᵢ_memₓ'. -/
-theorem countable_interᵢ_mem [Countable ι] {s : ι → Set α} : (⋂ i, s i) ∈ l ↔ ∀ i, s i ∈ l :=
-  interₛ_range s ▸ (countable_interₛ_mem (countable_range _)).trans forall_range_iff
-#align countable_Inter_mem countable_interᵢ_mem
+  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (Set.iInter.{u1, u2} α ι (fun (i : ι) => s i)) l) (forall (i : ι), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (s i) l)
+Case conversion may be inaccurate. Consider using '#align countable_Inter_mem countable_iInter_memₓ'. -/
+theorem countable_iInter_mem [Countable ι] {s : ι → Set α} : (⋂ i, s i) ∈ l ↔ ∀ i, s i ∈ l :=
+  sInter_range s ▸ (countable_sInter_mem (countable_range _)).trans forall_range_iff
+#align countable_Inter_mem countable_iInter_mem
 
 #print countable_bInter_mem /-
 theorem countable_bInter_mem {ι : Type _} {S : Set ι} (hS : S.Countable) {s : ∀ i ∈ S, Set α} :
@@ -85,7 +85,7 @@ Case conversion may be inaccurate. Consider using '#align eventually_countable_f
 theorem eventually_countable_forall [Countable ι] {p : α → ι → Prop} :
     (∀ᶠ x in l, ∀ i, p x i) ↔ ∀ i, ∀ᶠ x in l, p x i := by
   simpa only [Filter.Eventually, set_of_forall] using
-    @countable_interᵢ_mem _ _ l _ _ fun i => { x | p x i }
+    @countable_iInter_mem _ _ l _ _ fun i => { x | p x i }
 #align eventually_countable_forall eventually_countable_forall
 
 #print eventually_countable_ball /-
@@ -97,28 +97,28 @@ theorem eventually_countable_ball {ι : Type _} {S : Set ι} (hS : S.Countable)
 #align eventually_countable_ball eventually_countable_ball
 -/
 
-/- warning: eventually_le.countable_Union -> EventuallyLE.countable_unionᵢ is a dubious translation:
+/- warning: eventually_le.countable_Union -> EventuallyLE.countable_iUnion is a dubious translation:
 lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)} {t : ι -> (Set.{u2} α)}, (forall (i : ι), Filter.EventuallyLE.{u2, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLE.{u2, 0} α Prop Prop.le l (Set.unionᵢ.{u2, u1} α ι (fun (i : ι) => s i)) (Set.unionᵢ.{u2, u1} α ι (fun (i : ι) => t i)))
+  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)} {t : ι -> (Set.{u2} α)}, (forall (i : ι), Filter.EventuallyLE.{u2, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLE.{u2, 0} α Prop Prop.le l (Set.iUnion.{u2, u1} α ι (fun (i : ι) => s i)) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => t i)))
 but is expected to have type
-  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)} {t : ι -> (Set.{u1} α)}, (forall (i : ι), Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (Set.unionᵢ.{u1, u2} α ι (fun (i : ι) => s i)) (Set.unionᵢ.{u1, u2} α ι (fun (i : ι) => t i)))
-Case conversion may be inaccurate. Consider using '#align eventually_le.countable_Union EventuallyLE.countable_unionᵢₓ'. -/
-theorem EventuallyLE.countable_unionᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
+  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)} {t : ι -> (Set.{u1} α)}, (forall (i : ι), Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (Set.iUnion.{u1, u2} α ι (fun (i : ι) => s i)) (Set.iUnion.{u1, u2} α ι (fun (i : ι) => t i)))
+Case conversion may be inaccurate. Consider using '#align eventually_le.countable_Union EventuallyLE.countable_iUnionₓ'. -/
+theorem EventuallyLE.countable_iUnion [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
     (⋃ i, s i) ≤ᶠ[l] ⋃ i, t i :=
-  (eventually_countable_forall.2 h).mono fun x hst hs => mem_unionᵢ.2 <| (mem_unionᵢ.1 hs).imp hst
-#align eventually_le.countable_Union EventuallyLE.countable_unionᵢ
+  (eventually_countable_forall.2 h).mono fun x hst hs => mem_iUnion.2 <| (mem_iUnion.1 hs).imp hst
+#align eventually_le.countable_Union EventuallyLE.countable_iUnion
 
-/- warning: eventually_eq.countable_Union -> EventuallyEq.countable_unionᵢ is a dubious translation:
+/- warning: eventually_eq.countable_Union -> EventuallyEq.countable_iUnion is a dubious translation:
 lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)} {t : ι -> (Set.{u2} α)}, (forall (i : ι), Filter.EventuallyEq.{u2, 0} α Prop l (s i) (t i)) -> (Filter.EventuallyEq.{u2, 0} α Prop l (Set.unionᵢ.{u2, u1} α ι (fun (i : ι) => s i)) (Set.unionᵢ.{u2, u1} α ι (fun (i : ι) => t i)))
+  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)} {t : ι -> (Set.{u2} α)}, (forall (i : ι), Filter.EventuallyEq.{u2, 0} α Prop l (s i) (t i)) -> (Filter.EventuallyEq.{u2, 0} α Prop l (Set.iUnion.{u2, u1} α ι (fun (i : ι) => s i)) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => t i)))
 but is expected to have type
-  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)} {t : ι -> (Set.{u1} α)}, (forall (i : ι), Filter.EventuallyEq.{u1, 0} α Prop l (s i) (t i)) -> (Filter.EventuallyEq.{u1, 0} α Prop l (Set.unionᵢ.{u1, u2} α ι (fun (i : ι) => s i)) (Set.unionᵢ.{u1, u2} α ι (fun (i : ι) => t i)))
-Case conversion may be inaccurate. Consider using '#align eventually_eq.countable_Union EventuallyEq.countable_unionᵢₓ'. -/
-theorem EventuallyEq.countable_unionᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
+  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)} {t : ι -> (Set.{u1} α)}, (forall (i : ι), Filter.EventuallyEq.{u1, 0} α Prop l (s i) (t i)) -> (Filter.EventuallyEq.{u1, 0} α Prop l (Set.iUnion.{u1, u2} α ι (fun (i : ι) => s i)) (Set.iUnion.{u1, u2} α ι (fun (i : ι) => t i)))
+Case conversion may be inaccurate. Consider using '#align eventually_eq.countable_Union EventuallyEq.countable_iUnionₓ'. -/
+theorem EventuallyEq.countable_iUnion [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
     (⋃ i, s i) =ᶠ[l] ⋃ i, t i :=
-  (EventuallyLE.countable_unionᵢ fun i => (h i).le).antisymm
-    (EventuallyLE.countable_unionᵢ fun i => (h i).symm.le)
-#align eventually_eq.countable_Union EventuallyEq.countable_unionᵢ
+  (EventuallyLE.countable_iUnion fun i => (h i).le).antisymm
+    (EventuallyLE.countable_iUnion fun i => (h i).symm.le)
+#align eventually_eq.countable_Union EventuallyEq.countable_iUnion
 
 #print EventuallyLE.countable_bUnion /-
 theorem EventuallyLE.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countable)
@@ -127,7 +127,7 @@ theorem EventuallyLE.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countab
   by
   simp only [bUnion_eq_Union]
   haveI := hS.to_encodable
-  exact EventuallyLE.countable_unionᵢ fun i => h i i.2
+  exact EventuallyLE.countable_iUnion fun i => h i i.2
 #align eventually_le.countable_bUnion EventuallyLE.countable_bUnion
 -/
 
@@ -140,29 +140,29 @@ theorem EventuallyEq.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countab
 #align eventually_eq.countable_bUnion EventuallyEq.countable_bUnion
 -/
 
-/- warning: eventually_le.countable_Inter -> EventuallyLE.countable_interᵢ is a dubious translation:
+/- warning: eventually_le.countable_Inter -> EventuallyLE.countable_iInter is a dubious translation:
 lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)} {t : ι -> (Set.{u2} α)}, (forall (i : ι), Filter.EventuallyLE.{u2, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLE.{u2, 0} α Prop Prop.le l (Set.interᵢ.{u2, u1} α ι (fun (i : ι) => s i)) (Set.interᵢ.{u2, u1} α ι (fun (i : ι) => t i)))
+  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)} {t : ι -> (Set.{u2} α)}, (forall (i : ι), Filter.EventuallyLE.{u2, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLE.{u2, 0} α Prop Prop.le l (Set.iInter.{u2, u1} α ι (fun (i : ι) => s i)) (Set.iInter.{u2, u1} α ι (fun (i : ι) => t i)))
 but is expected to have type
-  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)} {t : ι -> (Set.{u1} α)}, (forall (i : ι), Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (Set.interᵢ.{u1, u2} α ι (fun (i : ι) => s i)) (Set.interᵢ.{u1, u2} α ι (fun (i : ι) => t i)))
-Case conversion may be inaccurate. Consider using '#align eventually_le.countable_Inter EventuallyLE.countable_interᵢₓ'. -/
-theorem EventuallyLE.countable_interᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
+  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)} {t : ι -> (Set.{u1} α)}, (forall (i : ι), Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (Set.iInter.{u1, u2} α ι (fun (i : ι) => s i)) (Set.iInter.{u1, u2} α ι (fun (i : ι) => t i)))
+Case conversion may be inaccurate. Consider using '#align eventually_le.countable_Inter EventuallyLE.countable_iInterₓ'. -/
+theorem EventuallyLE.countable_iInter [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
     (⋂ i, s i) ≤ᶠ[l] ⋂ i, t i :=
   (eventually_countable_forall.2 h).mono fun x hst hs =>
-    mem_interᵢ.2 fun i => hst _ (mem_interᵢ.1 hs i)
-#align eventually_le.countable_Inter EventuallyLE.countable_interᵢ
+    mem_iInter.2 fun i => hst _ (mem_iInter.1 hs i)
+#align eventually_le.countable_Inter EventuallyLE.countable_iInter
 
-/- warning: eventually_eq.countable_Inter -> EventuallyEq.countable_interᵢ is a dubious translation:
+/- warning: eventually_eq.countable_Inter -> EventuallyEq.countable_iInter is a dubious translation:
 lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)} {t : ι -> (Set.{u2} α)}, (forall (i : ι), Filter.EventuallyEq.{u2, 0} α Prop l (s i) (t i)) -> (Filter.EventuallyEq.{u2, 0} α Prop l (Set.interᵢ.{u2, u1} α ι (fun (i : ι) => s i)) (Set.interᵢ.{u2, u1} α ι (fun (i : ι) => t i)))
+  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)} {t : ι -> (Set.{u2} α)}, (forall (i : ι), Filter.EventuallyEq.{u2, 0} α Prop l (s i) (t i)) -> (Filter.EventuallyEq.{u2, 0} α Prop l (Set.iInter.{u2, u1} α ι (fun (i : ι) => s i)) (Set.iInter.{u2, u1} α ι (fun (i : ι) => t i)))
 but is expected to have type
-  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)} {t : ι -> (Set.{u1} α)}, (forall (i : ι), Filter.EventuallyEq.{u1, 0} α Prop l (s i) (t i)) -> (Filter.EventuallyEq.{u1, 0} α Prop l (Set.interᵢ.{u1, u2} α ι (fun (i : ι) => s i)) (Set.interᵢ.{u1, u2} α ι (fun (i : ι) => t i)))
-Case conversion may be inaccurate. Consider using '#align eventually_eq.countable_Inter EventuallyEq.countable_interᵢₓ'. -/
-theorem EventuallyEq.countable_interᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
+  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)} {t : ι -> (Set.{u1} α)}, (forall (i : ι), Filter.EventuallyEq.{u1, 0} α Prop l (s i) (t i)) -> (Filter.EventuallyEq.{u1, 0} α Prop l (Set.iInter.{u1, u2} α ι (fun (i : ι) => s i)) (Set.iInter.{u1, u2} α ι (fun (i : ι) => t i)))
+Case conversion may be inaccurate. Consider using '#align eventually_eq.countable_Inter EventuallyEq.countable_iInterₓ'. -/
+theorem EventuallyEq.countable_iInter [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
     (⋂ i, s i) =ᶠ[l] ⋂ i, t i :=
-  (EventuallyLE.countable_interᵢ fun i => (h i).le).antisymm
-    (EventuallyLE.countable_interᵢ fun i => (h i).symm.le)
-#align eventually_eq.countable_Inter EventuallyEq.countable_interᵢ
+  (EventuallyLE.countable_iInter fun i => (h i).le).antisymm
+    (EventuallyLE.countable_iInter fun i => (h i).symm.le)
+#align eventually_eq.countable_Inter EventuallyEq.countable_iInter
 
 #print EventuallyLE.countable_bInter /-
 theorem EventuallyLE.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countable)
@@ -171,7 +171,7 @@ theorem EventuallyLE.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countab
   by
   simp only [bInter_eq_Inter]
   haveI := hS.to_encodable
-  exact EventuallyLE.countable_interᵢ fun i => h i i.2
+  exact EventuallyLE.countable_iInter fun i => h i i.2
 #align eventually_le.countable_bInter EventuallyLE.countable_bInter
 -/
 
@@ -192,10 +192,10 @@ def Filter.ofCountableInter (l : Set (Set α))
     (h_mono : ∀ s t, s ∈ l → s ⊆ t → t ∈ l) : Filter α
     where
   sets := l
-  univ_sets := @interₛ_empty α ▸ hp _ countable_empty (empty_subset _)
+  univ_sets := @sInter_empty α ▸ hp _ countable_empty (empty_subset _)
   sets_of_superset := h_mono
   inter_sets s t hs ht :=
-    interₛ_pair s t ▸
+    sInter_pair s t ▸
       hp _ ((countable_singleton _).insert _) (insert_subset.2 ⟨hs, singleton_subset_iff.2 ht⟩)
 #align filter.of_countable_Inter Filter.ofCountableInter
 -/
@@ -220,7 +220,7 @@ theorem Filter.mem_ofCountableInter {l : Set (Set α)}
 
 #print countableInterFilter_principal /-
 instance countableInterFilter_principal (s : Set α) : CountableInterFilter (𝓟 s) :=
-  ⟨fun S hSc hS => subset_interₛ hS⟩
+  ⟨fun S hSc hS => subset_sInter hS⟩
 #align countable_Inter_filter_principal countableInterFilter_principal
 -/
 
@@ -292,7 +292,7 @@ Case conversion may be inaccurate. Consider using '#align countable_Inter_filter
 instance countableInterFilter_sup (l₁ l₂ : Filter α) [CountableInterFilter l₁]
     [CountableInterFilter l₂] : CountableInterFilter (l₁ ⊔ l₂) :=
   by
-  refine' ⟨fun S hSc hS => ⟨_, _⟩⟩ <;> refine' (countable_interₛ_mem hSc).2 fun s hs => _
+  refine' ⟨fun S hSc hS => ⟨_, _⟩⟩ <;> refine' (countable_sInter_mem hSc).2 fun s hs => _
   exacts[(hS s hs).1, (hS s hs).2]
 #align countable_Inter_filter_sup countableInterFilter_sup
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/195fcd60ff2bfe392543bceb0ec2adcdb472db4c

@@ -97,16 +97,16 @@ theorem eventually_countable_ball {ι : Type _} {S : Set ι} (hS : S.Countable)
 #align eventually_countable_ball eventually_countable_ball
 -/
 
-/- warning: eventually_le.countable_Union -> EventuallyLe.countable_unionᵢ is a dubious translation:
+/- warning: eventually_le.countable_Union -> EventuallyLE.countable_unionᵢ is a dubious translation:
 lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)} {t : ι -> (Set.{u2} α)}, (forall (i : ι), Filter.EventuallyLe.{u2, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLe.{u2, 0} α Prop Prop.le l (Set.unionᵢ.{u2, u1} α ι (fun (i : ι) => s i)) (Set.unionᵢ.{u2, u1} α ι (fun (i : ι) => t i)))
+  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)} {t : ι -> (Set.{u2} α)}, (forall (i : ι), Filter.EventuallyLE.{u2, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLE.{u2, 0} α Prop Prop.le l (Set.unionᵢ.{u2, u1} α ι (fun (i : ι) => s i)) (Set.unionᵢ.{u2, u1} α ι (fun (i : ι) => t i)))
 but is expected to have type
-  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)} {t : ι -> (Set.{u1} α)}, (forall (i : ι), Filter.EventuallyLe.{u1, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l (Set.unionᵢ.{u1, u2} α ι (fun (i : ι) => s i)) (Set.unionᵢ.{u1, u2} α ι (fun (i : ι) => t i)))
-Case conversion may be inaccurate. Consider using '#align eventually_le.countable_Union EventuallyLe.countable_unionᵢₓ'. -/
-theorem EventuallyLe.countable_unionᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
+  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)} {t : ι -> (Set.{u1} α)}, (forall (i : ι), Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (Set.unionᵢ.{u1, u2} α ι (fun (i : ι) => s i)) (Set.unionᵢ.{u1, u2} α ι (fun (i : ι) => t i)))
+Case conversion may be inaccurate. Consider using '#align eventually_le.countable_Union EventuallyLE.countable_unionᵢₓ'. -/
+theorem EventuallyLE.countable_unionᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
     (⋃ i, s i) ≤ᶠ[l] ⋃ i, t i :=
   (eventually_countable_forall.2 h).mono fun x hst hs => mem_unionᵢ.2 <| (mem_unionᵢ.1 hs).imp hst
-#align eventually_le.countable_Union EventuallyLe.countable_unionᵢ
+#align eventually_le.countable_Union EventuallyLE.countable_unionᵢ
 
 /- warning: eventually_eq.countable_Union -> EventuallyEq.countable_unionᵢ is a dubious translation:
 lean 3 declaration is
@@ -116,41 +116,41 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align eventually_eq.countable_Union EventuallyEq.countable_unionᵢₓ'. -/
 theorem EventuallyEq.countable_unionᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
     (⋃ i, s i) =ᶠ[l] ⋃ i, t i :=
-  (EventuallyLe.countable_unionᵢ fun i => (h i).le).antisymm
-    (EventuallyLe.countable_unionᵢ fun i => (h i).symm.le)
+  (EventuallyLE.countable_unionᵢ fun i => (h i).le).antisymm
+    (EventuallyLE.countable_unionᵢ fun i => (h i).symm.le)
 #align eventually_eq.countable_Union EventuallyEq.countable_unionᵢ
 
-#print EventuallyLe.countable_bUnion /-
-theorem EventuallyLe.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countable)
+#print EventuallyLE.countable_bUnion /-
+theorem EventuallyLE.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i ∈ S, s i ‹_› ≤ᶠ[l] t i ‹_›) :
     (⋃ i ∈ S, s i ‹_›) ≤ᶠ[l] ⋃ i ∈ S, t i ‹_› :=
   by
   simp only [bUnion_eq_Union]
   haveI := hS.to_encodable
-  exact EventuallyLe.countable_unionᵢ fun i => h i i.2
-#align eventually_le.countable_bUnion EventuallyLe.countable_bUnion
+  exact EventuallyLE.countable_unionᵢ fun i => h i i.2
+#align eventually_le.countable_bUnion EventuallyLE.countable_bUnion
 -/
 
 #print EventuallyEq.countable_bUnion /-
 theorem EventuallyEq.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i ∈ S, s i ‹_› =ᶠ[l] t i ‹_›) :
     (⋃ i ∈ S, s i ‹_›) =ᶠ[l] ⋃ i ∈ S, t i ‹_› :=
-  (EventuallyLe.countable_bUnion hS fun i hi => (h i hi).le).antisymm
-    (EventuallyLe.countable_bUnion hS fun i hi => (h i hi).symm.le)
+  (EventuallyLE.countable_bUnion hS fun i hi => (h i hi).le).antisymm
+    (EventuallyLE.countable_bUnion hS fun i hi => (h i hi).symm.le)
 #align eventually_eq.countable_bUnion EventuallyEq.countable_bUnion
 -/
 
-/- warning: eventually_le.countable_Inter -> EventuallyLe.countable_interᵢ is a dubious translation:
+/- warning: eventually_le.countable_Inter -> EventuallyLE.countable_interᵢ is a dubious translation:
 lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)} {t : ι -> (Set.{u2} α)}, (forall (i : ι), Filter.EventuallyLe.{u2, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLe.{u2, 0} α Prop Prop.le l (Set.interᵢ.{u2, u1} α ι (fun (i : ι) => s i)) (Set.interᵢ.{u2, u1} α ι (fun (i : ι) => t i)))
+  forall {ι : Sort.{u1}} {α : Type.{u2}} {l : Filter.{u2} α} [_inst_1 : CountableInterFilter.{u2} α l] [_inst_2 : Countable.{u1} ι] {s : ι -> (Set.{u2} α)} {t : ι -> (Set.{u2} α)}, (forall (i : ι), Filter.EventuallyLE.{u2, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLE.{u2, 0} α Prop Prop.le l (Set.interᵢ.{u2, u1} α ι (fun (i : ι) => s i)) (Set.interᵢ.{u2, u1} α ι (fun (i : ι) => t i)))
 but is expected to have type
-  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)} {t : ι -> (Set.{u1} α)}, (forall (i : ι), Filter.EventuallyLe.{u1, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l (Set.interᵢ.{u1, u2} α ι (fun (i : ι) => s i)) (Set.interᵢ.{u1, u2} α ι (fun (i : ι) => t i)))
-Case conversion may be inaccurate. Consider using '#align eventually_le.countable_Inter EventuallyLe.countable_interᵢₓ'. -/
-theorem EventuallyLe.countable_interᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
+  forall {ι : Sort.{u2}} {α : Type.{u1}} {l : Filter.{u1} α} [_inst_1 : CountableInterFilter.{u1} α l] [_inst_2 : Countable.{u2} ι] {s : ι -> (Set.{u1} α)} {t : ι -> (Set.{u1} α)}, (forall (i : ι), Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (s i) (t i)) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (Set.interᵢ.{u1, u2} α ι (fun (i : ι) => s i)) (Set.interᵢ.{u1, u2} α ι (fun (i : ι) => t i)))
+Case conversion may be inaccurate. Consider using '#align eventually_le.countable_Inter EventuallyLE.countable_interᵢₓ'. -/
+theorem EventuallyLE.countable_interᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
     (⋂ i, s i) ≤ᶠ[l] ⋂ i, t i :=
   (eventually_countable_forall.2 h).mono fun x hst hs =>
     mem_interᵢ.2 fun i => hst _ (mem_interᵢ.1 hs i)
-#align eventually_le.countable_Inter EventuallyLe.countable_interᵢ
+#align eventually_le.countable_Inter EventuallyLE.countable_interᵢ
 
 /- warning: eventually_eq.countable_Inter -> EventuallyEq.countable_interᵢ is a dubious translation:
 lean 3 declaration is
@@ -160,27 +160,27 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align eventually_eq.countable_Inter EventuallyEq.countable_interᵢₓ'. -/
 theorem EventuallyEq.countable_interᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
     (⋂ i, s i) =ᶠ[l] ⋂ i, t i :=
-  (EventuallyLe.countable_interᵢ fun i => (h i).le).antisymm
-    (EventuallyLe.countable_interᵢ fun i => (h i).symm.le)
+  (EventuallyLE.countable_interᵢ fun i => (h i).le).antisymm
+    (EventuallyLE.countable_interᵢ fun i => (h i).symm.le)
 #align eventually_eq.countable_Inter EventuallyEq.countable_interᵢ
 
-#print EventuallyLe.countable_bInter /-
-theorem EventuallyLe.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countable)
+#print EventuallyLE.countable_bInter /-
+theorem EventuallyLE.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i ∈ S, s i ‹_› ≤ᶠ[l] t i ‹_›) :
     (⋂ i ∈ S, s i ‹_›) ≤ᶠ[l] ⋂ i ∈ S, t i ‹_› :=
   by
   simp only [bInter_eq_Inter]
   haveI := hS.to_encodable
-  exact EventuallyLe.countable_interᵢ fun i => h i i.2
-#align eventually_le.countable_bInter EventuallyLe.countable_bInter
+  exact EventuallyLE.countable_interᵢ fun i => h i i.2
+#align eventually_le.countable_bInter EventuallyLE.countable_bInter
 -/
 
 #print EventuallyEq.countable_bInter /-
 theorem EventuallyEq.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i ∈ S, s i ‹_› =ᶠ[l] t i ‹_›) :
     (⋂ i ∈ S, s i ‹_›) =ᶠ[l] ⋂ i ∈ S, t i ‹_› :=
-  (EventuallyLe.countable_bInter hS fun i hi => (h i hi).le).antisymm
-    (EventuallyLe.countable_bInter hS fun i hi => (h i hi).symm.le)
+  (EventuallyLE.countable_bInter hS fun i hi => (h i hi).le).antisymm
+    (EventuallyLE.countable_bInter hS fun i hi => (h i hi).symm.le)
 #align eventually_eq.countable_bInter EventuallyEq.countable_bInter
 -/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/9da1b3534b65d9661eb8f42443598a92bbb49211

@@ -264,9 +264,9 @@ instance (l : Filter α) [CountableInterFilter l] (f : α → β) : CountableInt
 
 /- warning: countable_Inter_filter_inf -> countableInterFilter_inf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} (l₁ : Filter.{u1} α) (l₂ : Filter.{u1} α) [_inst_2 : CountableInterFilter.{u1} α l₁] [_inst_3 : CountableInterFilter.{u1} α l₂], CountableInterFilter.{u1} α (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l₁ l₂)
+  forall {α : Type.{u1}} (l₁ : Filter.{u1} α) (l₂ : Filter.{u1} α) [_inst_2 : CountableInterFilter.{u1} α l₁] [_inst_3 : CountableInterFilter.{u1} α l₂], CountableInterFilter.{u1} α (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l₁ l₂)
 but is expected to have type
-  forall {α : Type.{u1}} (l₁ : Filter.{u1} α) (l₂ : Filter.{u1} α) [_inst_2 : CountableInterFilter.{u1} α l₁] [_inst_3 : CountableInterFilter.{u1} α l₂], CountableInterFilter.{u1} α (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) l₁ l₂)
+  forall {α : Type.{u1}} (l₁ : Filter.{u1} α) (l₂ : Filter.{u1} α) [_inst_2 : CountableInterFilter.{u1} α l₁] [_inst_3 : CountableInterFilter.{u1} α l₂], CountableInterFilter.{u1} α (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l₁ l₂)
 Case conversion may be inaccurate. Consider using '#align countable_Inter_filter_inf countableInterFilter_infₓ'. -/
 /-- Infimum of two `countable_Inter_filter`s is a `countable_Inter_filter`. This is useful, e.g.,
 to automatically get an instance for `residual α ⊓ 𝓟 s`. -/
@@ -284,9 +284,9 @@ instance countableInterFilter_inf (l₁ l₂ : Filter α) [CountableInterFilter
 
 /- warning: countable_Inter_filter_sup -> countableInterFilter_sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} (l₁ : Filter.{u1} α) (l₂ : Filter.{u1} α) [_inst_2 : CountableInterFilter.{u1} α l₁] [_inst_3 : CountableInterFilter.{u1} α l₂], CountableInterFilter.{u1} α (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) l₁ l₂)
+  forall {α : Type.{u1}} (l₁ : Filter.{u1} α) (l₂ : Filter.{u1} α) [_inst_2 : CountableInterFilter.{u1} α l₁] [_inst_3 : CountableInterFilter.{u1} α l₂], CountableInterFilter.{u1} α (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) l₁ l₂)
 but is expected to have type
-  forall {α : Type.{u1}} (l₁ : Filter.{u1} α) (l₂ : Filter.{u1} α) [_inst_2 : CountableInterFilter.{u1} α l₁] [_inst_3 : CountableInterFilter.{u1} α l₂], CountableInterFilter.{u1} α (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) l₁ l₂)
+  forall {α : Type.{u1}} (l₁ : Filter.{u1} α) (l₂ : Filter.{u1} α) [_inst_2 : CountableInterFilter.{u1} α l₁] [_inst_3 : CountableInterFilter.{u1} α l₂], CountableInterFilter.{u1} α (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) l₁ l₂)
 Case conversion may be inaccurate. Consider using '#align countable_Inter_filter_sup countableInterFilter_supₓ'. -/
 /-- Supremum of two `countable_Inter_filter`s is a `countable_Inter_filter`. -/
 instance countableInterFilter_sup (l₁ l₂ : Filter α) [CountableInterFilter l₁]

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

Purely automatic replacement. If this is in any way controversial; I'm happy to just close this PR.

@@ -234,7 +234,7 @@ namespace Filter
 variable (g : Set (Set α))
 
 /-- `Filter.CountableGenerateSets g` is the (sets of the)
-greatest `countableInterFilter` containing `g`.-/
+greatest `countableInterFilter` containing `g`. -/
 inductive CountableGenerateSets : Set α → Prop
   | basic {s : Set α} : s ∈ g → CountableGenerateSets s
   | univ : CountableGenerateSets univ
@@ -243,7 +243,7 @@ inductive CountableGenerateSets : Set α → Prop
     S.Countable → (∀ s ∈ S, CountableGenerateSets s) → CountableGenerateSets (⋂₀ S)
 #align filter.countable_generate_sets Filter.CountableGenerateSets
 
-/-- `Filter.countableGenerate g` is the greatest `countableInterFilter` containing `g`.-/
+/-- `Filter.countableGenerate g` is the greatest `countableInterFilter` containing `g`. -/
 def countableGenerate : Filter α :=
   ofCountableInter (CountableGenerateSets g) (fun _ => CountableGenerateSets.sInter) fun _ _ =>
     CountableGenerateSets.superset
@@ -291,7 +291,7 @@ theorem le_countableGenerate_iff_of_countableInterFilter {f : Filter α} [Counta
 
 variable (g)
 
-/-- `countableGenerate g` is the greatest `countableInterFilter` containing `g`.-/
+/-- `countableGenerate g` is the greatest `countableInterFilter` containing `g`. -/
 theorem countableGenerate_isGreatest :
     IsGreatest { f : Filter α | CountableInterFilter f ∧ g ⊆ f.sets } (countableGenerate g) := by
   refine' ⟨⟨inferInstance, fun s => CountableGenerateSets.basic⟩, _⟩

extend more of the API from CountableInterFilter to CardinalInterFilter

Co-authored-by: Oliver Nash <github@olivernash.org>

@@ -131,26 +131,26 @@ theorem EventuallyEq.countable_bInter {ι : Type*} {S : Set ι} (hS : S.Countabl
 /-- Construct a filter with countable intersection property. This constructor deduces
 `Filter.univ_sets` and `Filter.inter_sets` from the countable intersection property. -/
 def Filter.ofCountableInter (l : Set (Set α))
-    (hp : ∀ S : Set (Set α), S.Countable → S ⊆ l → ⋂₀ S ∈ l)
+    (hl : ∀ S : Set (Set α), S.Countable → S ⊆ l → ⋂₀ S ∈ l)
     (h_mono : ∀ s t, s ∈ l → s ⊆ t → t ∈ l) : Filter α where
   sets := l
-  univ_sets := @sInter_empty α ▸ hp _ countable_empty (empty_subset _)
+  univ_sets := @sInter_empty α ▸ hl _ countable_empty (empty_subset _)
   sets_of_superset := h_mono _ _
   inter_sets {s t} hs ht := sInter_pair s t ▸
-    hp _ ((countable_singleton _).insert _) (insert_subset_iff.2 ⟨hs, singleton_subset_iff.2 ht⟩)
+    hl _ ((countable_singleton _).insert _) (insert_subset_iff.2 ⟨hs, singleton_subset_iff.2 ht⟩)
 #align filter.of_countable_Inter Filter.ofCountableInter
 
 instance Filter.countableInter_ofCountableInter (l : Set (Set α))
-    (hp : ∀ S : Set (Set α), S.Countable → S ⊆ l → ⋂₀ S ∈ l)
+    (hl : ∀ S : Set (Set α), S.Countable → S ⊆ l → ⋂₀ S ∈ l)
     (h_mono : ∀ s t, s ∈ l → s ⊆ t → t ∈ l) :
-    CountableInterFilter (Filter.ofCountableInter l hp h_mono) :=
-  ⟨hp⟩
+    CountableInterFilter (Filter.ofCountableInter l hl h_mono) :=
+  ⟨hl⟩
 #align filter.countable_Inter_of_countable_Inter Filter.countableInter_ofCountableInter
 
 @[simp]
 theorem Filter.mem_ofCountableInter {l : Set (Set α)}
-    (hp : ∀ S : Set (Set α), S.Countable → S ⊆ l → ⋂₀ S ∈ l) (h_mono : ∀ s t, s ∈ l → s ⊆ t → t ∈ l)
-    {s : Set α} : s ∈ Filter.ofCountableInter l hp h_mono ↔ s ∈ l :=
+    (hl : ∀ S : Set (Set α), S.Countable → S ⊆ l → ⋂₀ S ∈ l) (h_mono : ∀ s t, s ∈ l → s ⊆ t → t ∈ l)
+    {s : Set α} : s ∈ Filter.ofCountableInter l hl h_mono ↔ s ∈ l :=
   Iff.rfl
 #align filter.mem_of_countable_Inter Filter.mem_ofCountableInter
 
@@ -158,25 +158,28 @@ theorem Filter.mem_ofCountableInter {l : Set (Set α)}
 Similarly to `Filter.comk`, a set belongs to this filter if its complement satisfies the property.
 Similarly to `Filter.ofCountableInter`,
 this constructor deduces some properties from the countable intersection property
-which becomes the countable union property because we take complements of all sets.
-
-Another small difference from `Filter.ofCountableInter`
-is that this definition takes `p : Set α → Prop` instead of `Set (Set α)`. -/
-def Filter.ofCountableUnion (p : Set α → Prop)
-    (hUnion : ∀ S : Set (Set α), S.Countable → (∀ s ∈ S, p s) → p (⋃₀ S))
-    (hmono : ∀ t, p t → ∀ s ⊆ t, p s) : Filter α := by
-  refine .ofCountableInter {s | p sᶜ} (fun S hSc hSp ↦ ?_) fun s t ht hsub ↦ ?_
+which becomes the countable union property because we take complements of all sets. -/
+def Filter.ofCountableUnion (l : Set (Set α))
+    (hUnion : ∀ S : Set (Set α), S.Countable → (∀ s ∈ S, s ∈ l) → ⋃₀ S ∈ l)
+    (hmono : ∀ t ∈ l, ∀ s ⊆ t, s ∈ l) : Filter α := by
+  refine .ofCountableInter {s | sᶜ ∈ l} (fun S hSc hSp ↦ ?_) fun s t ht hsub ↦ ?_
   · rw [mem_setOf_eq, compl_sInter]
-    exact hUnion _ (hSc.image _) (forall_mem_image.2 hSp)
-  · exact hmono _ ht _ (compl_subset_compl.2 hsub)
-
-instance Filter.countableInter_ofCountableUnion (p : Set α → Prop) (h₁ h₂) :
-    CountableInterFilter (Filter.ofCountableUnion p h₁ h₂) :=
+    apply hUnion (compl '' S) (hSc.image _)
+    intro s hs
+    rw [mem_image] at hs
+    rcases hs with ⟨t, ht, rfl⟩
+    apply hSp ht
+  · rw [mem_setOf_eq]
+    rw [← compl_subset_compl] at hsub
+    exact hmono sᶜ ht tᶜ hsub
+
+instance Filter.countableInter_ofCountableUnion (l : Set (Set α)) (h₁ h₂) :
+    CountableInterFilter (Filter.ofCountableUnion l h₁ h₂) :=
   countableInter_ofCountableInter ..
 
 @[simp]
-theorem Filter.mem_ofCountableUnion {p : Set α → Prop} {hunion hmono s} :
-    s ∈ ofCountableUnion p hunion hmono ↔ p sᶜ :=
+theorem Filter.mem_ofCountableUnion {l : Set (Set α)} {hunion hmono s} :
+    s ∈ ofCountableUnion l hunion hmono ↔ l sᶜ :=
   Iff.rfl
 
 instance countableInterFilter_principal (s : Set α) : CountableInterFilter (𝓟 s) :=

CardinalInterFilter generalizes CountableInterFilter to allow for a specific cardinality, where the filter must be stable under intersections over a number of sets lower than this cardinality.

Prepares the way for K-Lindelöf spaces.

@@ -22,6 +22,10 @@ and provide instances for some basic constructions (`⊥`, `⊤`, `Filter.princi
 `Filter.comap`, `Inf.inf`). We also provide a custom constructor `Filter.ofCountableInter`
 that deduces two axioms of a `Filter` from the countable intersection property.
 
+Note that there also exists a typeclass `CardinalInterFilter`, and thus an alternative spelling of
+`CountableInterFilter` as `CardinalInterFilter l (aleph 1)`. The former (defined here) is the
+preferred spelling; it has the advantage of not requiring the user to import the theory ordinals.
+
 ## Tags
 filter, countable
 -/

ball for "bounded forall" and bex for "bounded exists" are from experience very confusing abbreviations. This PR renames them to forall_mem and exists_mem in the few Set lemma names that mention them.

Also deprecate ball_image_of_ball, mem_image_elim, mem_image_elim_on since those lemmas are duplicates of the renamed lemmas (apart from argument order and implicitness, which I am also fixing by making the binder in the RHS of forall_mem_image semi-implicit), have obscure names and are completely unused.

@@ -48,7 +48,7 @@ theorem countable_sInter_mem {S : Set (Set α)} (hSc : S.Countable) : ⋂₀ S 
 #align countable_sInter_mem countable_sInter_mem
 
 theorem countable_iInter_mem [Countable ι] {s : ι → Set α} : (⋂ i, s i) ∈ l ↔ ∀ i, s i ∈ l :=
-  sInter_range s ▸ (countable_sInter_mem (countable_range _)).trans forall_range_iff
+  sInter_range s ▸ (countable_sInter_mem (countable_range _)).trans forall_mem_range
 #align countable_Inter_mem countable_iInter_mem
 
 theorem countable_bInter_mem {ι : Type*} {S : Set ι} (hS : S.Countable) {s : ∀ i ∈ S, Set α} :
@@ -163,7 +163,7 @@ def Filter.ofCountableUnion (p : Set α → Prop)
     (hmono : ∀ t, p t → ∀ s ⊆ t, p s) : Filter α := by
   refine .ofCountableInter {s | p sᶜ} (fun S hSc hSp ↦ ?_) fun s t ht hsub ↦ ?_
   · rw [mem_setOf_eq, compl_sInter]
-    exact hUnion _ (hSc.image _) (ball_image_iff.2 hSp)
+    exact hUnion _ (hSc.image _) (forall_mem_image.2 hSp)
   · exact hmono _ ht _ (compl_subset_compl.2 hsub)
 
 instance Filter.countableInter_ofCountableUnion (p : Set α → Prop) (h₁ h₂) :

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

• converts "--porting note" into "-- Porting note";
• converts "porting note" into "Porting note".

@@ -243,7 +243,7 @@ def countableGenerate : Filter α :=
   --deriving CountableInterFilter
 #align filter.countable_generate Filter.countableGenerate
 
---Porting note: could not de derived
+-- Porting note: could not de derived
 instance : CountableInterFilter (countableGenerate g) := by
   delta countableGenerate; infer_instance
 

I replaced a few "terminal" refine/refine's with exact.

The strategy was very simple-minded: essentially any refine whose following line had smaller indentation got replaced by exact and then I cleaned up the mess.

This PR certainly leaves some further terminal refines, but maybe the current change is beneficial.

@@ -263,7 +263,7 @@ theorem mem_countableGenerate_iff {s : Set α} :
     refine' ⟨⋃ (s) (H : s ∈ S), T s H, by simpa, Sct.biUnion Tct, _⟩
     apply subset_sInter
     intro s H
-    refine' subset_trans (sInter_subset_sInter (subset_iUnion₂ s H)) (hT s H)
+    exact subset_trans (sInter_subset_sInter (subset_iUnion₂ s H)) (hT s H)
   rcases h with ⟨S, Sg, Sct, hS⟩
   refine' mem_of_superset ((countable_sInter_mem Sct).mpr _) hS
   intro s H

Add two constructors to create filters from a property on sets:

• Filter.comk if the property is stable under finite unions and set shrinking.
• Filter.ofCountableUnion if the property is stable under countable unions and set shrinking

Filter.comk is the key ingredient in IsCompact.induction_on but may be convenient to have as individual building block. A Filter generated by Filter.ofCountableUnion is a CountableInterFilter, which is given by the instance Filter.countableInter_ofCountableUnion.

Other changes

• Use Filter.comk for Filter.cofinite, Bornology.ofBounded and MeasureTheory.Measure.cofinite.
• Use Filter.ofCountableUnion for MeasureTheory.Measure.ae.
• Use {_ : Bornology _} instead of [Bornology _] in some lemmas so that rw/simp work with non-instance bornologies.

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

@@ -150,6 +150,31 @@ theorem Filter.mem_ofCountableInter {l : Set (Set α)}
   Iff.rfl
 #align filter.mem_of_countable_Inter Filter.mem_ofCountableInter
 
+/-- Construct a filter with countable intersection property.
+Similarly to `Filter.comk`, a set belongs to this filter if its complement satisfies the property.
+Similarly to `Filter.ofCountableInter`,
+this constructor deduces some properties from the countable intersection property
+which becomes the countable union property because we take complements of all sets.
+
+Another small difference from `Filter.ofCountableInter`
+is that this definition takes `p : Set α → Prop` instead of `Set (Set α)`. -/
+def Filter.ofCountableUnion (p : Set α → Prop)
+    (hUnion : ∀ S : Set (Set α), S.Countable → (∀ s ∈ S, p s) → p (⋃₀ S))
+    (hmono : ∀ t, p t → ∀ s ⊆ t, p s) : Filter α := by
+  refine .ofCountableInter {s | p sᶜ} (fun S hSc hSp ↦ ?_) fun s t ht hsub ↦ ?_
+  · rw [mem_setOf_eq, compl_sInter]
+    exact hUnion _ (hSc.image _) (ball_image_iff.2 hSp)
+  · exact hmono _ ht _ (compl_subset_compl.2 hsub)
+
+instance Filter.countableInter_ofCountableUnion (p : Set α → Prop) (h₁ h₂) :
+    CountableInterFilter (Filter.ofCountableUnion p h₁ h₂) :=
+  countableInter_ofCountableInter ..
+
+@[simp]
+theorem Filter.mem_ofCountableUnion {p : Set α → Prop} {hunion hmono s} :
+    s ∈ ofCountableUnion p hunion hmono ↔ p sᶜ :=
+  Iff.rfl
+
 instance countableInterFilter_principal (s : Set α) : CountableInterFilter (𝓟 s) :=
   ⟨fun _ _ hS => subset_sInter hS⟩
 #align countable_Inter_filter_principal countableInterFilter_principal

@@ -136,12 +136,12 @@ def Filter.ofCountableInter (l : Set (Set α))
     hp _ ((countable_singleton _).insert _) (insert_subset_iff.2 ⟨hs, singleton_subset_iff.2 ht⟩)
 #align filter.of_countable_Inter Filter.ofCountableInter
 
-instance Filter.countable_Inter_ofCountableInter (l : Set (Set α))
+instance Filter.countableInter_ofCountableInter (l : Set (Set α))
     (hp : ∀ S : Set (Set α), S.Countable → S ⊆ l → ⋂₀ S ∈ l)
     (h_mono : ∀ s t, s ∈ l → s ⊆ t → t ∈ l) :
     CountableInterFilter (Filter.ofCountableInter l hp h_mono) :=
   ⟨hp⟩
-#align filter.countable_Inter_of_countable_Inter Filter.countable_Inter_ofCountableInter
+#align filter.countable_Inter_of_countable_Inter Filter.countableInter_ofCountableInter
 
 @[simp]
 theorem Filter.mem_ofCountableInter {l : Set (Set α)}

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

@@ -31,7 +31,7 @@ open Set Filter
 
 open Filter
 
-variable {ι : Sort _} {α β : Type _}
+variable {ι : Sort*} {α β : Type*}
 
 /-- A filter `l` has the countable intersection property if for any countable collection
 of sets `s ∈ l` their intersection belongs to `l` as well. -/
@@ -51,7 +51,7 @@ theorem countable_iInter_mem [Countable ι] {s : ι → Set α} : (⋂ i, s i) 
   sInter_range s ▸ (countable_sInter_mem (countable_range _)).trans forall_range_iff
 #align countable_Inter_mem countable_iInter_mem
 
-theorem countable_bInter_mem {ι : Type _} {S : Set ι} (hS : S.Countable) {s : ∀ i ∈ S, Set α} :
+theorem countable_bInter_mem {ι : Type*} {S : Set ι} (hS : S.Countable) {s : ∀ i ∈ S, Set α} :
     (⋂ i, ⋂ hi : i ∈ S, s i ‹_›) ∈ l ↔ ∀ i, ∀ hi : i ∈ S, s i ‹_› ∈ l := by
   rw [biInter_eq_iInter]
   haveI := hS.toEncodable
@@ -64,7 +64,7 @@ theorem eventually_countable_forall [Countable ι] {p : α → ι → Prop} :
     @countable_iInter_mem _ _ l _ _ fun i => { x | p x i }
 #align eventually_countable_forall eventually_countable_forall
 
-theorem eventually_countable_ball {ι : Type _} {S : Set ι} (hS : S.Countable)
+theorem eventually_countable_ball {ι : Type*} {S : Set ι} (hS : S.Countable)
     {p : α → ∀ i ∈ S, Prop} :
     (∀ᶠ x in l, ∀ i hi, p x i hi) ↔ ∀ i hi, ∀ᶠ x in l, p x i hi := by
   simpa only [Filter.Eventually, setOf_forall] using
@@ -82,7 +82,7 @@ theorem EventuallyEq.countable_iUnion [Countable ι] {s t : ι → Set α} (h :
     (EventuallyLE.countable_iUnion fun i => (h i).symm.le)
 #align eventually_eq.countable_Union EventuallyEq.countable_iUnion
 
-theorem EventuallyLE.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countable)
+theorem EventuallyLE.countable_bUnion {ι : Type*} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi ≤ᶠ[l] t i hi) :
     ⋃ i ∈ S, s i ‹_› ≤ᶠ[l] ⋃ i ∈ S, t i ‹_› := by
   simp only [biUnion_eq_iUnion]
@@ -90,7 +90,7 @@ theorem EventuallyLE.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countab
   exact EventuallyLE.countable_iUnion fun i => h i i.2
 #align eventually_le.countable_bUnion EventuallyLE.countable_bUnion
 
-theorem EventuallyEq.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countable)
+theorem EventuallyEq.countable_bUnion {ι : Type*} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi =ᶠ[l] t i hi) :
     ⋃ i ∈ S, s i ‹_› =ᶠ[l] ⋃ i ∈ S, t i ‹_› :=
   (EventuallyLE.countable_bUnion hS fun i hi => (h i hi).le).antisymm
@@ -109,7 +109,7 @@ theorem EventuallyEq.countable_iInter [Countable ι] {s t : ι → Set α} (h :
     (EventuallyLE.countable_iInter fun i => (h i).symm.le)
 #align eventually_eq.countable_Inter EventuallyEq.countable_iInter
 
-theorem EventuallyLE.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countable)
+theorem EventuallyLE.countable_bInter {ι : Type*} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi ≤ᶠ[l] t i hi) :
     ⋂ i ∈ S, s i ‹_› ≤ᶠ[l] ⋂ i ∈ S, t i ‹_› := by
   simp only [biInter_eq_iInter]
@@ -117,7 +117,7 @@ theorem EventuallyLE.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countab
   exact EventuallyLE.countable_iInter fun i => h i i.2
 #align eventually_le.countable_bInter EventuallyLE.countable_bInter
 
-theorem EventuallyEq.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countable)
+theorem EventuallyEq.countable_bInter {ι : Type*} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi =ᶠ[l] t i hi) :
     ⋂ i ∈ S, s i ‹_› =ᶠ[l] ⋂ i ∈ S, t i ‹_› :=
   (EventuallyLE.countable_bInter hS fun i hi => (h i hi).le).antisymm

• depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -2,15 +2,12 @@
 Copyright (c) 2020 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
-
-! This file was ported from Lean 3 source module order.filter.countable_Inter
-! leanprover-community/mathlib commit b9e46fe101fc897fb2e7edaf0bf1f09ea49eb81a
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.Filter.Basic
 import Mathlib.Data.Set.Countable
 
+#align_import order.filter.countable_Inter from "leanprover-community/mathlib"@"b9e46fe101fc897fb2e7edaf0bf1f09ea49eb81a"
+
 /-!
 # Filters with countable intersection property
 

@@ -75,19 +75,19 @@ theorem eventually_countable_ball {ι : Type _} {S : Set ι} (hS : S.Countable)
 #align eventually_countable_ball eventually_countable_ball
 
 theorem EventuallyLE.countable_iUnion [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
-    (⋃ i, s i) ≤ᶠ[l] ⋃ i, t i :=
+    ⋃ i, s i ≤ᶠ[l] ⋃ i, t i :=
   (eventually_countable_forall.2 h).mono fun _ hst hs => mem_iUnion.2 <| (mem_iUnion.1 hs).imp hst
 #align eventually_le.countable_Union EventuallyLE.countable_iUnion
 
 theorem EventuallyEq.countable_iUnion [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
-    (⋃ i, s i) =ᶠ[l] ⋃ i, t i :=
+    ⋃ i, s i =ᶠ[l] ⋃ i, t i :=
   (EventuallyLE.countable_iUnion fun i => (h i).le).antisymm
     (EventuallyLE.countable_iUnion fun i => (h i).symm.le)
 #align eventually_eq.countable_Union EventuallyEq.countable_iUnion
 
 theorem EventuallyLE.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi ≤ᶠ[l] t i hi) :
-    (⋃ i ∈ S, s i ‹_›) ≤ᶠ[l] ⋃ i ∈ S, t i ‹_› := by
+    ⋃ i ∈ S, s i ‹_› ≤ᶠ[l] ⋃ i ∈ S, t i ‹_› := by
   simp only [biUnion_eq_iUnion]
   haveI := hS.toEncodable
   exact EventuallyLE.countable_iUnion fun i => h i i.2
@@ -95,26 +95,26 @@ theorem EventuallyLE.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countab
 
 theorem EventuallyEq.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi =ᶠ[l] t i hi) :
-    (⋃ i ∈ S, s i ‹_›) =ᶠ[l] ⋃ i ∈ S, t i ‹_› :=
+    ⋃ i ∈ S, s i ‹_› =ᶠ[l] ⋃ i ∈ S, t i ‹_› :=
   (EventuallyLE.countable_bUnion hS fun i hi => (h i hi).le).antisymm
     (EventuallyLE.countable_bUnion hS fun i hi => (h i hi).symm.le)
 #align eventually_eq.countable_bUnion EventuallyEq.countable_bUnion
 
 theorem EventuallyLE.countable_iInter [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
-    (⋂ i, s i) ≤ᶠ[l] ⋂ i, t i :=
+    ⋂ i, s i ≤ᶠ[l] ⋂ i, t i :=
   (eventually_countable_forall.2 h).mono fun _ hst hs =>
     mem_iInter.2 fun i => hst _ (mem_iInter.1 hs i)
 #align eventually_le.countable_Inter EventuallyLE.countable_iInter
 
 theorem EventuallyEq.countable_iInter [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
-    (⋂ i, s i) =ᶠ[l] ⋂ i, t i :=
+    ⋂ i, s i =ᶠ[l] ⋂ i, t i :=
   (EventuallyLE.countable_iInter fun i => (h i).le).antisymm
     (EventuallyLE.countable_iInter fun i => (h i).symm.le)
 #align eventually_eq.countable_Inter EventuallyEq.countable_iInter
 
 theorem EventuallyLE.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi ≤ᶠ[l] t i hi) :
-    (⋂ i ∈ S, s i ‹_›) ≤ᶠ[l] ⋂ i ∈ S, t i ‹_› := by
+    ⋂ i ∈ S, s i ‹_› ≤ᶠ[l] ⋂ i ∈ S, t i ‹_› := by
   simp only [biInter_eq_iInter]
   haveI := hS.toEncodable
   exact EventuallyLE.countable_iInter fun i => h i i.2
@@ -122,7 +122,7 @@ theorem EventuallyLE.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countab
 
 theorem EventuallyEq.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi =ᶠ[l] t i hi) :
-    (⋂ i ∈ S, s i ‹_›) =ᶠ[l] ⋂ i ∈ S, t i ‹_› :=
+    ⋂ i ∈ S, s i ‹_› =ᶠ[l] ⋂ i ∈ S, t i ‹_› :=
   (EventuallyLE.countable_bInter hS fun i hi => (h i hi).le).antisymm
     (EventuallyLE.countable_bInter hS fun i hi => (h i hi).symm.le)
 #align eventually_eq.countable_bInter EventuallyEq.countable_bInter

Currently, (for both Set and Finset) insert_subset is an iff lemma stating that insert a s ⊆ t if and only if a ∈ t and s ⊆ t. For both types, this PR renames this lemma to insert_subset_iff, and adds an insert_subset lemma that gives the implication just in the reverse direction : namely theorem insert_subset (ha : a ∈ t) (hs : s ⊆ t) : insert a s ⊆ t .

This both aligns the naming with union_subset and union_subset_iff, and removes the need for the awkward insert_subset.mpr ⟨_,_⟩ idiom. It touches a lot of files (too many to list), but in a trivial way.

@@ -136,7 +136,7 @@ def Filter.ofCountableInter (l : Set (Set α))
   univ_sets := @sInter_empty α ▸ hp _ countable_empty (empty_subset _)
   sets_of_superset := h_mono _ _
   inter_sets {s t} hs ht := sInter_pair s t ▸
-    hp _ ((countable_singleton _).insert _) (insert_subset.2 ⟨hs, singleton_subset_iff.2 ht⟩)
+    hp _ ((countable_singleton _).insert _) (insert_subset_iff.2 ⟨hs, singleton_subset_iff.2 ht⟩)
 #align filter.of_countable_Inter Filter.ofCountableInter
 
 instance Filter.countable_Inter_ofCountableInter (l : Set (Set α))

Changes are of the form

• some_tactic at h⊢ -> some_tactic at h ⊢
• some_tactic at h -> some_tactic at h

@@ -177,7 +177,7 @@ instance (l : Filter β) [CountableInterFilter l] (f : α → β) :
 
 instance (l : Filter α) [CountableInterFilter l] (f : α → β) : CountableInterFilter (map f l) := by
   refine' ⟨fun S hSc hS => _⟩
-  simp only [mem_map, sInter_eq_biInter, preimage_iInter₂] at hS⊢
+  simp only [mem_map, sInter_eq_biInter, preimage_iInter₂] at hS ⊢
   exact (countable_bInter_mem hSc).2 hS
 
 /-- Infimum of two `CountableInterFilter`s is a `CountableInterFilter`. This is useful, e.g.,

@@ -131,8 +131,7 @@ theorem EventuallyEq.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countab
 `Filter.univ_sets` and `Filter.inter_sets` from the countable intersection property. -/
 def Filter.ofCountableInter (l : Set (Set α))
     (hp : ∀ S : Set (Set α), S.Countable → S ⊆ l → ⋂₀ S ∈ l)
-    (h_mono : ∀ s t, s ∈ l → s ⊆ t → t ∈ l) : Filter α
-    where
+    (h_mono : ∀ s t, s ∈ l → s ⊆ t → t ∈ l) : Filter α where
   sets := l
   univ_sets := @sInter_empty α ▸ hp _ countable_empty (empty_subset _)
   sets_of_superset := h_mono _ _

Too often tempted to change these during other PRs, so doing a mass edit here.

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

@@ -198,7 +198,7 @@ instance countableInterFilter_inf (l₁ l₂ : Filter α) [CountableInterFilter
 instance countableInterFilter_sup (l₁ l₂ : Filter α) [CountableInterFilter l₁]
     [CountableInterFilter l₂] : CountableInterFilter (l₁ ⊔ l₂) := by
   refine' ⟨fun S hSc hS => ⟨_, _⟩⟩ <;> refine' (countable_sInter_mem hSc).2 fun s hs => _
-  exacts[(hS s hs).1, (hS s hs).2]
+  exacts [(hS s hs).1, (hS s hs).2]
 #align countable_Inter_filter_sup countableInterFilter_sup
 
 namespace Filter

• Run a non-interactive version of fix-comments.py on all files.
• Go through the diff and manually add/discard/edit chunks.

@@ -18,9 +18,9 @@ In this file we define `CountableInterFilter` to be the class of filters with th
 property: for any countable collection of sets `s ∈ l` their intersection belongs to `l` as well.
 
 Two main examples are the `residual` filter defined in `Mathlib.Topology.GDelta` and
-the `measure.ae` filter defined in `measure_theory.measure_space`.
+the `MeasureTheory.Measure.ae` filter defined in `MeasureTheory.MeasureSpace`.
 
-We reformulate the definition in terms of indexed intersection and in terms of `filter.eventually`
+We reformulate the definition in terms of indexed intersection and in terms of `Filter.Eventually`
 and provide instances for some basic constructions (`⊥`, `⊤`, `Filter.principal`, `Filter.map`,
 `Filter.comap`, `Inf.inf`). We also provide a custom constructor `Filter.ofCountableInter`
 that deduces two axioms of a `Filter` from the countable intersection property.
@@ -181,7 +181,7 @@ instance (l : Filter α) [CountableInterFilter l] (f : α → β) : CountableInt
   simp only [mem_map, sInter_eq_biInter, preimage_iInter₂] at hS⊢
   exact (countable_bInter_mem hSc).2 hS
 
-/-- Infimum of two `countable_Inter_filter`s is a `countable_Inter_filter`. This is useful, e.g.,
+/-- Infimum of two `CountableInterFilter`s is a `CountableInterFilter`. This is useful, e.g.,
 to automatically get an instance for `residual α ⊓ 𝓟 s`. -/
 instance countableInterFilter_inf (l₁ l₂ : Filter α) [CountableInterFilter l₁]
     [CountableInterFilter l₂] : CountableInterFilter (l₁ ⊓ l₂) := by
@@ -194,7 +194,7 @@ instance countableInterFilter_inf (l₁ l₂ : Filter α) [CountableInterFilter
   apply inter_subset_inter <;> exact iInter_subset_of_subset i (iInter_subset _ _)
 #align countable_Inter_filter_inf countableInterFilter_inf
 
-/-- Supremum of two `countable_Inter_filter`s is a `countable_Inter_filter`. -/
+/-- Supremum of two `CountableInterFilter`s is a `CountableInterFilter`. -/
 instance countableInterFilter_sup (l₁ l₂ : Filter α) [CountableInterFilter l₁]
     [CountableInterFilter l₂] : CountableInterFilter (l₁ ⊔ l₂) := by
   refine' ⟨fun S hSc hS => ⟨_, _⟩⟩ <;> refine' (countable_sInter_mem hSc).2 fun s hs => _

Co-authored-by: Chris Hughes <33847686+ChrisHughes24@users.noreply.github.com>

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
 
 ! This file was ported from Lean 3 source module order.filter.countable_Inter
-! leanprover-community/mathlib commit 8631e2d5ea77f6c13054d9151d82b83069680cb1
+! leanprover-community/mathlib commit b9e46fe101fc897fb2e7edaf0bf1f09ea49eb81a
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -17,7 +17,7 @@ import Mathlib.Data.Set.Countable
 In this file we define `CountableInterFilter` to be the class of filters with the following
 property: for any countable collection of sets `s ∈ l` their intersection belongs to `l` as well.
 
-Two main examples are the `residual` filter defined in `Mathlib.Topology.MetricSpace.Baire` and
+Two main examples are the `residual` filter defined in `Mathlib.Topology.GDelta` and
 the `measure.ae` filter defined in `measure_theory.measure_space`.
 
 We reformulate the definition in terms of indexed intersection and in terms of `filter.eventually`
@@ -200,3 +200,75 @@ instance countableInterFilter_sup (l₁ l₂ : Filter α) [CountableInterFilter
   refine' ⟨fun S hSc hS => ⟨_, _⟩⟩ <;> refine' (countable_sInter_mem hSc).2 fun s hs => _
   exacts[(hS s hs).1, (hS s hs).2]
 #align countable_Inter_filter_sup countableInterFilter_sup
+
+namespace Filter
+
+variable (g : Set (Set α))
+
+/-- `Filter.CountableGenerateSets g` is the (sets of the)
+greatest `countableInterFilter` containing `g`.-/
+inductive CountableGenerateSets : Set α → Prop
+  | basic {s : Set α} : s ∈ g → CountableGenerateSets s
+  | univ : CountableGenerateSets univ
+  | superset {s t : Set α} : CountableGenerateSets s → s ⊆ t → CountableGenerateSets t
+  | sInter {S : Set (Set α)} :
+    S.Countable → (∀ s ∈ S, CountableGenerateSets s) → CountableGenerateSets (⋂₀ S)
+#align filter.countable_generate_sets Filter.CountableGenerateSets
+
+/-- `Filter.countableGenerate g` is the greatest `countableInterFilter` containing `g`.-/
+def countableGenerate : Filter α :=
+  ofCountableInter (CountableGenerateSets g) (fun _ => CountableGenerateSets.sInter) fun _ _ =>
+    CountableGenerateSets.superset
+  --deriving CountableInterFilter
+#align filter.countable_generate Filter.countableGenerate
+
+--Porting note: could not de derived
+instance : CountableInterFilter (countableGenerate g) := by
+  delta countableGenerate; infer_instance
+
+variable {g}
+
+/-- A set is in the `countableInterFilter` generated by `g` if and only if
+it contains a countable intersection of elements of `g`. -/
+theorem mem_countableGenerate_iff {s : Set α} :
+    s ∈ countableGenerate g ↔ ∃ S : Set (Set α), S ⊆ g ∧ S.Countable ∧ ⋂₀ S ⊆ s := by
+  constructor <;> intro h
+  · induction' h with s hs s t _ st ih S Sct _ ih
+    · exact ⟨{s}, by simp [hs, subset_refl]⟩
+    · exact ⟨∅, by simp⟩
+    · refine' Exists.imp (fun S => _) ih
+      tauto
+    choose T Tg Tct hT using ih
+    refine' ⟨⋃ (s) (H : s ∈ S), T s H, by simpa, Sct.biUnion Tct, _⟩
+    apply subset_sInter
+    intro s H
+    refine' subset_trans (sInter_subset_sInter (subset_iUnion₂ s H)) (hT s H)
+  rcases h with ⟨S, Sg, Sct, hS⟩
+  refine' mem_of_superset ((countable_sInter_mem Sct).mpr _) hS
+  intro s H
+  exact CountableGenerateSets.basic (Sg H)
+#align filter.mem_countable_generate_iff Filter.mem_countableGenerate_iff
+
+theorem le_countableGenerate_iff_of_countableInterFilter {f : Filter α} [CountableInterFilter f] :
+    f ≤ countableGenerate g ↔ g ⊆ f.sets := by
+  constructor <;> intro h
+  · exact subset_trans (fun s => CountableGenerateSets.basic) h
+  intro s hs
+  induction' hs with s hs s t _ st ih S Sct _ ih
+  · exact h hs
+  · exact univ_mem
+  · exact mem_of_superset ih st
+  exact (countable_sInter_mem Sct).mpr ih
+#align filter.le_countable_generate_iff_of_countable_Inter_filter Filter.le_countableGenerate_iff_of_countableInterFilter
+
+variable (g)
+
+/-- `countableGenerate g` is the greatest `countableInterFilter` containing `g`.-/
+theorem countableGenerate_isGreatest :
+    IsGreatest { f : Filter α | CountableInterFilter f ∧ g ⊆ f.sets } (countableGenerate g) := by
+  refine' ⟨⟨inferInstance, fun s => CountableGenerateSets.basic⟩, _⟩
+  rintro f ⟨fct, hf⟩
+  rwa [@le_countableGenerate_iff_of_countableInterFilter _ _ _ fct]
+#align filter.countable_generate_is_greatest Filter.countableGenerate_isGreatest
+
+end Filter

As discussed on Zulip

Renames

• supₛ → sSup
• infₛ → sInf
• supᵢ → iSup
• infᵢ → iInf
• bsupₛ → bsSup
• binfₛ → bsInf
• bsupᵢ → biSup
• binfᵢ → biInf
• csupₛ → csSup
• cinfₛ → csInf
• csupᵢ → ciSup
• cinfᵢ → ciInf
• unionₛ → sUnion
• interₛ → sInter
• unionᵢ → iUnion
• interᵢ → iInter
• bunionₛ → bsUnion
• binterₛ → bsInter
• bunionᵢ → biUnion
• binterᵢ → biInter

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -40,31 +40,31 @@ variable {ι : Sort _} {α β : Type _}
 of sets `s ∈ l` their intersection belongs to `l` as well. -/
 class CountableInterFilter (l : Filter α) : Prop where
   /-- For a countable collection of sets `s ∈ l`, their intersection belongs to `l` as well. -/
-  countable_interₛ_mem : ∀ S : Set (Set α), S.Countable → (∀ s ∈ S, s ∈ l) → ⋂₀ S ∈ l
+  countable_sInter_mem : ∀ S : Set (Set α), S.Countable → (∀ s ∈ S, s ∈ l) → ⋂₀ S ∈ l
 #align countable_Inter_filter CountableInterFilter
 
 variable {l : Filter α} [CountableInterFilter l]
 
-theorem countable_interₛ_mem {S : Set (Set α)} (hSc : S.Countable) : ⋂₀ S ∈ l ↔ ∀ s ∈ S, s ∈ l :=
-  ⟨fun hS _s hs => mem_of_superset hS (interₛ_subset_of_mem hs),
-    CountableInterFilter.countable_interₛ_mem _ hSc⟩
-#align countable_sInter_mem countable_interₛ_mem
+theorem countable_sInter_mem {S : Set (Set α)} (hSc : S.Countable) : ⋂₀ S ∈ l ↔ ∀ s ∈ S, s ∈ l :=
+  ⟨fun hS _s hs => mem_of_superset hS (sInter_subset_of_mem hs),
+    CountableInterFilter.countable_sInter_mem _ hSc⟩
+#align countable_sInter_mem countable_sInter_mem
 
-theorem countable_interᵢ_mem [Countable ι] {s : ι → Set α} : (⋂ i, s i) ∈ l ↔ ∀ i, s i ∈ l :=
-  interₛ_range s ▸ (countable_interₛ_mem (countable_range _)).trans forall_range_iff
-#align countable_Inter_mem countable_interᵢ_mem
+theorem countable_iInter_mem [Countable ι] {s : ι → Set α} : (⋂ i, s i) ∈ l ↔ ∀ i, s i ∈ l :=
+  sInter_range s ▸ (countable_sInter_mem (countable_range _)).trans forall_range_iff
+#align countable_Inter_mem countable_iInter_mem
 
 theorem countable_bInter_mem {ι : Type _} {S : Set ι} (hS : S.Countable) {s : ∀ i ∈ S, Set α} :
     (⋂ i, ⋂ hi : i ∈ S, s i ‹_›) ∈ l ↔ ∀ i, ∀ hi : i ∈ S, s i ‹_› ∈ l := by
-  rw [binterᵢ_eq_interᵢ]
+  rw [biInter_eq_iInter]
   haveI := hS.toEncodable
-  exact countable_interᵢ_mem.trans Subtype.forall
+  exact countable_iInter_mem.trans Subtype.forall
 #align countable_bInter_mem countable_bInter_mem
 
 theorem eventually_countable_forall [Countable ι] {p : α → ι → Prop} :
     (∀ᶠ x in l, ∀ i, p x i) ↔ ∀ i, ∀ᶠ x in l, p x i := by
   simpa only [Filter.Eventually, setOf_forall] using
-    @countable_interᵢ_mem _ _ l _ _ fun i => { x | p x i }
+    @countable_iInter_mem _ _ l _ _ fun i => { x | p x i }
 #align eventually_countable_forall eventually_countable_forall
 
 theorem eventually_countable_ball {ι : Type _} {S : Set ι} (hS : S.Countable)
@@ -74,23 +74,23 @@ theorem eventually_countable_ball {ι : Type _} {S : Set ι} (hS : S.Countable)
     @countable_bInter_mem _ l _ _ _ hS fun i hi => { x | p x i hi }
 #align eventually_countable_ball eventually_countable_ball
 
-theorem EventuallyLE.countable_unionᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
+theorem EventuallyLE.countable_iUnion [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
     (⋃ i, s i) ≤ᶠ[l] ⋃ i, t i :=
-  (eventually_countable_forall.2 h).mono fun _ hst hs => mem_unionᵢ.2 <| (mem_unionᵢ.1 hs).imp hst
-#align eventually_le.countable_Union EventuallyLE.countable_unionᵢ
+  (eventually_countable_forall.2 h).mono fun _ hst hs => mem_iUnion.2 <| (mem_iUnion.1 hs).imp hst
+#align eventually_le.countable_Union EventuallyLE.countable_iUnion
 
-theorem EventuallyEq.countable_unionᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
+theorem EventuallyEq.countable_iUnion [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
     (⋃ i, s i) =ᶠ[l] ⋃ i, t i :=
-  (EventuallyLE.countable_unionᵢ fun i => (h i).le).antisymm
-    (EventuallyLE.countable_unionᵢ fun i => (h i).symm.le)
-#align eventually_eq.countable_Union EventuallyEq.countable_unionᵢ
+  (EventuallyLE.countable_iUnion fun i => (h i).le).antisymm
+    (EventuallyLE.countable_iUnion fun i => (h i).symm.le)
+#align eventually_eq.countable_Union EventuallyEq.countable_iUnion
 
 theorem EventuallyLE.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi ≤ᶠ[l] t i hi) :
     (⋃ i ∈ S, s i ‹_›) ≤ᶠ[l] ⋃ i ∈ S, t i ‹_› := by
-  simp only [bunionᵢ_eq_unionᵢ]
+  simp only [biUnion_eq_iUnion]
   haveI := hS.toEncodable
-  exact EventuallyLE.countable_unionᵢ fun i => h i i.2
+  exact EventuallyLE.countable_iUnion fun i => h i i.2
 #align eventually_le.countable_bUnion EventuallyLE.countable_bUnion
 
 theorem EventuallyEq.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countable)
@@ -100,24 +100,24 @@ theorem EventuallyEq.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countab
     (EventuallyLE.countable_bUnion hS fun i hi => (h i hi).symm.le)
 #align eventually_eq.countable_bUnion EventuallyEq.countable_bUnion
 
-theorem EventuallyLE.countable_interᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
+theorem EventuallyLE.countable_iInter [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
     (⋂ i, s i) ≤ᶠ[l] ⋂ i, t i :=
   (eventually_countable_forall.2 h).mono fun _ hst hs =>
-    mem_interᵢ.2 fun i => hst _ (mem_interᵢ.1 hs i)
-#align eventually_le.countable_Inter EventuallyLE.countable_interᵢ
+    mem_iInter.2 fun i => hst _ (mem_iInter.1 hs i)
+#align eventually_le.countable_Inter EventuallyLE.countable_iInter
 
-theorem EventuallyEq.countable_interᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
+theorem EventuallyEq.countable_iInter [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
     (⋂ i, s i) =ᶠ[l] ⋂ i, t i :=
-  (EventuallyLE.countable_interᵢ fun i => (h i).le).antisymm
-    (EventuallyLE.countable_interᵢ fun i => (h i).symm.le)
-#align eventually_eq.countable_Inter EventuallyEq.countable_interᵢ
+  (EventuallyLE.countable_iInter fun i => (h i).le).antisymm
+    (EventuallyLE.countable_iInter fun i => (h i).symm.le)
+#align eventually_eq.countable_Inter EventuallyEq.countable_iInter
 
 theorem EventuallyLE.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi ≤ᶠ[l] t i hi) :
     (⋂ i ∈ S, s i ‹_›) ≤ᶠ[l] ⋂ i ∈ S, t i ‹_› := by
-  simp only [binterᵢ_eq_interᵢ]
+  simp only [biInter_eq_iInter]
   haveI := hS.toEncodable
-  exact EventuallyLE.countable_interᵢ fun i => h i i.2
+  exact EventuallyLE.countable_iInter fun i => h i i.2
 #align eventually_le.countable_bInter EventuallyLE.countable_bInter
 
 theorem EventuallyEq.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countable)
@@ -134,9 +134,9 @@ def Filter.ofCountableInter (l : Set (Set α))
     (h_mono : ∀ s t, s ∈ l → s ⊆ t → t ∈ l) : Filter α
     where
   sets := l
-  univ_sets := @interₛ_empty α ▸ hp _ countable_empty (empty_subset _)
+  univ_sets := @sInter_empty α ▸ hp _ countable_empty (empty_subset _)
   sets_of_superset := h_mono _ _
-  inter_sets {s t} hs ht := interₛ_pair s t ▸
+  inter_sets {s t} hs ht := sInter_pair s t ▸
     hp _ ((countable_singleton _).insert _) (insert_subset.2 ⟨hs, singleton_subset_iff.2 ht⟩)
 #align filter.of_countable_Inter Filter.ofCountableInter
 
@@ -155,7 +155,7 @@ theorem Filter.mem_ofCountableInter {l : Set (Set α)}
 #align filter.mem_of_countable_Inter Filter.mem_ofCountableInter
 
 instance countableInterFilter_principal (s : Set α) : CountableInterFilter (𝓟 s) :=
-  ⟨fun _ _ hS => subset_interₛ hS⟩
+  ⟨fun _ _ hS => subset_sInter hS⟩
 #align countable_Inter_filter_principal countableInterFilter_principal
 
 instance countableInterFilter_bot : CountableInterFilter (⊥ : Filter α) := by
@@ -174,11 +174,11 @@ instance (l : Filter β) [CountableInterFilter l] (f : α → β) :
   choose! t htl ht using hS
   have : (⋂ s ∈ S, t s) ∈ l := (countable_bInter_mem hSc).2 htl
   refine' ⟨_, this, _⟩
-  simpa [preimage_interᵢ] using interᵢ₂_mono ht
+  simpa [preimage_iInter] using iInter₂_mono ht
 
 instance (l : Filter α) [CountableInterFilter l] (f : α → β) : CountableInterFilter (map f l) := by
   refine' ⟨fun S hSc hS => _⟩
-  simp only [mem_map, interₛ_eq_binterᵢ, preimage_interᵢ₂] at hS⊢
+  simp only [mem_map, sInter_eq_biInter, preimage_iInter₂] at hS⊢
   exact (countable_bInter_mem hSc).2 hS
 
 /-- Infimum of two `countable_Inter_filter`s is a `countable_Inter_filter`. This is useful, e.g.,
@@ -189,14 +189,14 @@ instance countableInterFilter_inf (l₁ l₂ : Filter α) [CountableInterFilter
   choose s hs t ht hst using hS
   replace hs : (⋂ i ∈ S, s i ‹_›) ∈ l₁ := (countable_bInter_mem hSc).2 hs
   replace ht : (⋂ i ∈ S, t i ‹_›) ∈ l₂ := (countable_bInter_mem hSc).2 ht
-  refine' mem_of_superset (inter_mem_inf hs ht) (subset_interₛ fun i hi => _)
+  refine' mem_of_superset (inter_mem_inf hs ht) (subset_sInter fun i hi => _)
   rw [hst i hi]
-  apply inter_subset_inter <;> exact interᵢ_subset_of_subset i (interᵢ_subset _ _)
+  apply inter_subset_inter <;> exact iInter_subset_of_subset i (iInter_subset _ _)
 #align countable_Inter_filter_inf countableInterFilter_inf
 
 /-- Supremum of two `countable_Inter_filter`s is a `countable_Inter_filter`. -/
 instance countableInterFilter_sup (l₁ l₂ : Filter α) [CountableInterFilter l₁]
     [CountableInterFilter l₂] : CountableInterFilter (l₁ ⊔ l₂) := by
-  refine' ⟨fun S hSc hS => ⟨_, _⟩⟩ <;> refine' (countable_interₛ_mem hSc).2 fun s hs => _
+  refine' ⟨fun S hSc hS => ⟨_, _⟩⟩ <;> refine' (countable_sInter_mem hSc).2 fun s hs => _
   exacts[(hS s hs).1, (hS s hs).2]
 #align countable_Inter_filter_sup countableInterFilter_sup

@@ -74,57 +74,57 @@ theorem eventually_countable_ball {ι : Type _} {S : Set ι} (hS : S.Countable)
     @countable_bInter_mem _ l _ _ _ hS fun i hi => { x | p x i hi }
 #align eventually_countable_ball eventually_countable_ball
 
-theorem EventuallyLe.countable_unionᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
+theorem EventuallyLE.countable_unionᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
     (⋃ i, s i) ≤ᶠ[l] ⋃ i, t i :=
   (eventually_countable_forall.2 h).mono fun _ hst hs => mem_unionᵢ.2 <| (mem_unionᵢ.1 hs).imp hst
-#align eventually_le.countable_Union EventuallyLe.countable_unionᵢ
+#align eventually_le.countable_Union EventuallyLE.countable_unionᵢ
 
 theorem EventuallyEq.countable_unionᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
     (⋃ i, s i) =ᶠ[l] ⋃ i, t i :=
-  (EventuallyLe.countable_unionᵢ fun i => (h i).le).antisymm
-    (EventuallyLe.countable_unionᵢ fun i => (h i).symm.le)
+  (EventuallyLE.countable_unionᵢ fun i => (h i).le).antisymm
+    (EventuallyLE.countable_unionᵢ fun i => (h i).symm.le)
 #align eventually_eq.countable_Union EventuallyEq.countable_unionᵢ
 
-theorem EventuallyLe.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countable)
+theorem EventuallyLE.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi ≤ᶠ[l] t i hi) :
     (⋃ i ∈ S, s i ‹_›) ≤ᶠ[l] ⋃ i ∈ S, t i ‹_› := by
   simp only [bunionᵢ_eq_unionᵢ]
   haveI := hS.toEncodable
-  exact EventuallyLe.countable_unionᵢ fun i => h i i.2
-#align eventually_le.countable_bUnion EventuallyLe.countable_bUnion
+  exact EventuallyLE.countable_unionᵢ fun i => h i i.2
+#align eventually_le.countable_bUnion EventuallyLE.countable_bUnion
 
 theorem EventuallyEq.countable_bUnion {ι : Type _} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi =ᶠ[l] t i hi) :
     (⋃ i ∈ S, s i ‹_›) =ᶠ[l] ⋃ i ∈ S, t i ‹_› :=
-  (EventuallyLe.countable_bUnion hS fun i hi => (h i hi).le).antisymm
-    (EventuallyLe.countable_bUnion hS fun i hi => (h i hi).symm.le)
+  (EventuallyLE.countable_bUnion hS fun i hi => (h i hi).le).antisymm
+    (EventuallyLE.countable_bUnion hS fun i hi => (h i hi).symm.le)
 #align eventually_eq.countable_bUnion EventuallyEq.countable_bUnion
 
-theorem EventuallyLe.countable_interᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
+theorem EventuallyLE.countable_interᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
     (⋂ i, s i) ≤ᶠ[l] ⋂ i, t i :=
   (eventually_countable_forall.2 h).mono fun _ hst hs =>
     mem_interᵢ.2 fun i => hst _ (mem_interᵢ.1 hs i)
-#align eventually_le.countable_Inter EventuallyLe.countable_interᵢ
+#align eventually_le.countable_Inter EventuallyLE.countable_interᵢ
 
 theorem EventuallyEq.countable_interᵢ [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
     (⋂ i, s i) =ᶠ[l] ⋂ i, t i :=
-  (EventuallyLe.countable_interᵢ fun i => (h i).le).antisymm
-    (EventuallyLe.countable_interᵢ fun i => (h i).symm.le)
+  (EventuallyLE.countable_interᵢ fun i => (h i).le).antisymm
+    (EventuallyLE.countable_interᵢ fun i => (h i).symm.le)
 #align eventually_eq.countable_Inter EventuallyEq.countable_interᵢ
 
-theorem EventuallyLe.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countable)
+theorem EventuallyLE.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi ≤ᶠ[l] t i hi) :
     (⋂ i ∈ S, s i ‹_›) ≤ᶠ[l] ⋂ i ∈ S, t i ‹_› := by
   simp only [binterᵢ_eq_interᵢ]
   haveI := hS.toEncodable
-  exact EventuallyLe.countable_interᵢ fun i => h i i.2
-#align eventually_le.countable_bInter EventuallyLe.countable_bInter
+  exact EventuallyLE.countable_interᵢ fun i => h i i.2
+#align eventually_le.countable_bInter EventuallyLE.countable_bInter
 
 theorem EventuallyEq.countable_bInter {ι : Type _} {S : Set ι} (hS : S.Countable)
     {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi =ᶠ[l] t i hi) :
     (⋂ i ∈ S, s i ‹_›) =ᶠ[l] ⋂ i ∈ S, t i ‹_› :=
-  (EventuallyLe.countable_bInter hS fun i hi => (h i hi).le).antisymm
-    (EventuallyLe.countable_bInter hS fun i hi => (h i hi).symm.le)
+  (EventuallyLE.countable_bInter hS fun i hi => (h i hi).le).antisymm
+    (EventuallyLE.countable_bInter hS fun i hi => (h i hi).symm.le)
 #align eventually_eq.countable_bInter EventuallyEq.countable_bInter
 
 /-- Construct a filter with countable intersection property. This constructor deduces

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

@@ -22,7 +22,7 @@ the `measure.ae` filter defined in `measure_theory.measure_space`.
 
 We reformulate the definition in terms of indexed intersection and in terms of `filter.eventually`
 and provide instances for some basic constructions (`⊥`, `⊤`, `Filter.principal`, `Filter.map`,
-`Filter.comap`, `HasInf.inf`). We also provide a custom constructor `Filter.ofCountableInter`
+`Filter.comap`, `Inf.inf`). We also provide a custom constructor `Filter.ofCountableInter`
 that deduces two axioms of a `Filter` from the countable intersection property.
 
 ## Tags