topology.algebra.filter_basis ⟷ Mathlib.Topology.Algebra.FilterBasis

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

@@ -215,11 +215,11 @@ theorem nhds_eq (B : GroupFilterBasis G) {x₀ : G} : @nhds G B.topology x₀ =
   by
   rw [TopologicalSpace.nhds_mkOfNhds]
   · intro x U U_in
-    rw [(B.has_basis x).mem_iff] at U_in 
+    rw [(B.has_basis x).mem_iff] at U_in
     rcases U_in with ⟨V, V_in, H⟩
     simpa [mem_pure] using H (mem_image_of_mem _ (GroupFilterBasis.one V_in))
   · intro x U U_in
-    rw [(B.has_basis x).mem_iff] at U_in 
+    rw [(B.has_basis x).mem_iff] at U_in
     rcases U_in with ⟨V, V_in, H⟩
     rcases GroupFilterBasis.mul V_in with ⟨W, W_in, hW⟩
     use(fun y => x * y) '' W, image_mem_map (FilterBasis.mem_filter_of_mem _ W_in)
@@ -435,18 +435,18 @@ instance [DiscreteTopology R] : Inhabited (ModuleFilterBasis R M) :=
         default with
       smul' := by
         rintro U (h : U ∈ {{(0 : M)}})
-        rw [mem_singleton_iff] at h 
+        rw [mem_singleton_iff] at h
         use univ, univ_mem, {0}, rfl
         rintro a ⟨x, m, -, hm, rfl⟩
         simp [mem_singleton_iff.1 hm, h]
       smul_left' := by
         rintro x₀ U (h : U ∈ {{(0 : M)}})
-        rw [mem_singleton_iff] at h 
+        rw [mem_singleton_iff] at h
         use{0}, rfl
         simp [h]
       smul_right' := by
         rintro m₀ U (h : U ∈ (0 : Set (Set M)))
-        rw [Set.mem_zero] at h 
+        rw [Set.mem_zero] at h
         simp [h, nhds_discrete] }⟩
 
 #print ModuleFilterBasis.topology /-

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

@@ -166,12 +166,12 @@ instance : Inhabited (GroupFilterBasis G) :=
       use{1}
       simp⟩
 
-#print GroupFilterBasis.prod_subset_self /-
+#print GroupFilterBasis.subset_mul_self /-
 @[to_additive]
-theorem prod_subset_self (B : GroupFilterBasis G) {U : Set G} (h : U ∈ B) : U ⊆ U * U :=
+theorem subset_mul_self (B : GroupFilterBasis G) {U : Set G} (h : U ∈ B) : U ⊆ U * U :=
   fun x x_in => ⟨1, x, one h, x_in, one_mul x⟩
-#align group_filter_basis.prod_subset_self GroupFilterBasis.prod_subset_self
-#align add_group_filter_basis.sum_subset_self AddGroupFilterBasis.sum_subset_self
+#align group_filter_basis.prod_subset_self GroupFilterBasis.subset_mul_self
+#align add_group_filter_basis.sum_subset_self AddGroupFilterBasis.subset_add_self
 -/
 
 #print GroupFilterBasis.N /-

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

@@ -3,8 +3,8 @@ Copyright (c) 2021 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot
 -/
-import Mathbin.Order.Filter.Bases
-import Mathbin.Topology.Algebra.Module.Basic
+import Order.Filter.Bases
+import Topology.Algebra.Module.Basic
 
 #align_import topology.algebra.filter_basis from "leanprover-community/mathlib"@"19cb3751e5e9b3d97adb51023949c50c13b5fdfd"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

@@ -315,8 +315,8 @@ end GroupFilterBasis
   topology on `R` which is compatible with the ring structure.  -/
 class RingFilterBasis (R : Type u) [Ring R] extends AddGroupFilterBasis R where
   mul' : ∀ {U}, U ∈ sets → ∃ V ∈ sets, V * V ⊆ U
-  mul_left' : ∀ (x₀ : R) {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x => x₀ * x) ⁻¹' U
-  mul_right' : ∀ (x₀ : R) {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x => x * x₀) ⁻¹' U
+  hMul_left' : ∀ (x₀ : R) {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x => x₀ * x) ⁻¹' U
+  hMul_right' : ∀ (x₀ : R) {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x => x * x₀) ⁻¹' U
 #align ring_filter_basis RingFilterBasis
 -/
 
@@ -335,13 +335,13 @@ theorem mul {U : Set R} (hU : U ∈ B) : ∃ V ∈ B, V * V ⊆ U :=
 
 #print RingFilterBasis.mul_left /-
 theorem mul_left (x₀ : R) {U : Set R} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x => x₀ * x) ⁻¹' U :=
-  mul_left' x₀ hU
+  hMul_left' x₀ hU
 #align ring_filter_basis.mul_left RingFilterBasis.mul_left
 -/
 
 #print RingFilterBasis.mul_right /-
 theorem mul_right (x₀ : R) {U : Set R} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x => x * x₀) ⁻¹' U :=
-  mul_right' x₀ hU
+  hMul_right' x₀ hU
 #align ring_filter_basis.mul_right RingFilterBasis.mul_right
 -/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/63721b2c3eba6c325ecf8ae8cca27155a4f6306f

@@ -153,17 +153,17 @@ instance : Inhabited (GroupFilterBasis G) :=
         Nonempty := singleton_nonempty _ .. }
     all_goals simp only [exists_prop, mem_singleton_iff]
     · rintro - - rfl rfl
-      use {1}
+      use{1}
       simp
     · simp
     · rintro - rfl
-      use {1}
+      use{1}
       simp
     · rintro - rfl
-      use {1}
+      use{1}
       simp
     · rintro x₀ - rfl
-      use {1}
+      use{1}
       simp⟩
 
 #print GroupFilterBasis.prod_subset_self /-
@@ -222,7 +222,7 @@ theorem nhds_eq (B : GroupFilterBasis G) {x₀ : G} : @nhds G B.topology x₀ =
     rw [(B.has_basis x).mem_iff] at U_in 
     rcases U_in with ⟨V, V_in, H⟩
     rcases GroupFilterBasis.mul V_in with ⟨W, W_in, hW⟩
-    use (fun y => x * y) '' W, image_mem_map (FilterBasis.mem_filter_of_mem _ W_in)
+    use(fun y => x * y) '' W, image_mem_map (FilterBasis.mem_filter_of_mem _ W_in)
     constructor
     · rw [image_subset_iff] at H ⊢
       exact ((B.prod_subset_self W_in).trans hW).trans H
@@ -442,7 +442,7 @@ instance [DiscreteTopology R] : Inhabited (ModuleFilterBasis R M) :=
       smul_left' := by
         rintro x₀ U (h : U ∈ {{(0 : M)}})
         rw [mem_singleton_iff] at h 
-        use {0}, rfl
+        use{0}, rfl
         simp [h]
       smul_right' := by
         rintro m₀ U (h : U ∈ (0 : Set (Set M)))

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

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot
-
-! This file was ported from Lean 3 source module topology.algebra.filter_basis
-! leanprover-community/mathlib commit 19cb3751e5e9b3d97adb51023949c50c13b5fdfd
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Filter.Bases
 import Mathbin.Topology.Algebra.Module.Basic
 
+#align_import topology.algebra.filter_basis from "leanprover-community/mathlib"@"19cb3751e5e9b3d97adb51023949c50c13b5fdfd"
+
 /-!
 # Group and ring filter bases
 

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

@@ -87,6 +87,7 @@ attribute [to_additive] GroupFilterBasis.conj'
 
 attribute [to_additive] GroupFilterBasis.toFilterBasis
 
+#print groupFilterBasisOfComm /-
 /-- `group_filter_basis` constructor in the commutative group case. -/
 @[to_additive "`add_group_filter_basis` constructor in the additive commutative group case."]
 def groupFilterBasisOfComm {G : Type _} [CommGroup G] (sets : Set (Set G))
@@ -102,6 +103,7 @@ def groupFilterBasisOfComm {G : Type _} [CommGroup G] (sets : Set (Set G))
     conj' := fun x U U_in => ⟨U, U_in, by simp⟩ }
 #align group_filter_basis_of_comm groupFilterBasisOfComm
 #align add_group_filter_basis_of_comm addGroupFilterBasisOfComm
+-/
 
 namespace GroupFilterBasis
 
@@ -111,29 +113,37 @@ variable {G : Type u} [Group G] {B : GroupFilterBasis G}
 instance : Membership (Set G) (GroupFilterBasis G) :=
   ⟨fun s f => s ∈ f.sets⟩
 
+#print GroupFilterBasis.one /-
 @[to_additive]
 theorem one {U : Set G} : U ∈ B → (1 : G) ∈ U :=
   GroupFilterBasis.one'
 #align group_filter_basis.one GroupFilterBasis.one
 #align add_group_filter_basis.zero AddGroupFilterBasis.zero
+-/
 
+#print GroupFilterBasis.mul /-
 @[to_additive]
 theorem mul {U : Set G} : U ∈ B → ∃ V ∈ B, V * V ⊆ U :=
   GroupFilterBasis.mul'
 #align group_filter_basis.mul GroupFilterBasis.mul
 #align add_group_filter_basis.add AddGroupFilterBasis.add
+-/
 
+#print GroupFilterBasis.inv /-
 @[to_additive]
 theorem inv {U : Set G} : U ∈ B → ∃ V ∈ B, V ⊆ (fun x => x⁻¹) ⁻¹' U :=
   GroupFilterBasis.inv'
 #align group_filter_basis.inv GroupFilterBasis.inv
 #align add_group_filter_basis.neg AddGroupFilterBasis.neg
+-/
 
+#print GroupFilterBasis.conj /-
 @[to_additive]
 theorem conj : ∀ x₀, ∀ {U}, U ∈ B → ∃ V ∈ B, V ⊆ (fun x => x₀ * x * x₀⁻¹) ⁻¹' U :=
   GroupFilterBasis.conj'
 #align group_filter_basis.conj GroupFilterBasis.conj
 #align add_group_filter_basis.conj AddGroupFilterBasis.conj
+-/
 
 /-- The trivial group filter basis consists of `{1}` only. The associated topology
 is discrete. -/
@@ -159,11 +169,13 @@ instance : Inhabited (GroupFilterBasis G) :=
       use {1}
       simp⟩
 
+#print GroupFilterBasis.prod_subset_self /-
 @[to_additive]
 theorem prod_subset_self (B : GroupFilterBasis G) {U : Set G} (h : U ∈ B) : U ⊆ U * U :=
   fun x x_in => ⟨1, x, one h, x_in, one_mul x⟩
 #align group_filter_basis.prod_subset_self GroupFilterBasis.prod_subset_self
 #align add_group_filter_basis.sum_subset_self AddGroupFilterBasis.sum_subset_self
+-/
 
 #print GroupFilterBasis.N /-
 /-- The neighborhood function of a `group_filter_basis` -/
@@ -174,18 +186,22 @@ def N (B : GroupFilterBasis G) : G → Filter G := fun x =>
 #align add_group_filter_basis.N AddGroupFilterBasis.N
 -/
 
+#print GroupFilterBasis.N_one /-
 @[simp, to_additive]
 theorem N_one (B : GroupFilterBasis G) : B.N 1 = B.toFilterBasis.filterₓ := by
   simp only [N, one_mul, map_id']
 #align group_filter_basis.N_one GroupFilterBasis.N_one
 #align add_group_filter_basis.N_zero AddGroupFilterBasis.N_zero
+-/
 
+#print GroupFilterBasis.hasBasis /-
 @[to_additive]
 protected theorem hasBasis (B : GroupFilterBasis G) (x : G) :
     HasBasis (B.N x) (fun V : Set G => V ∈ B) fun V => (fun y => x * y) '' V :=
   HasBasis.map (fun y => x * y) toFilterBasis.HasBasis
 #align group_filter_basis.has_basis GroupFilterBasis.hasBasis
 #align add_group_filter_basis.has_basis AddGroupFilterBasis.hasBasis
+-/
 
 #print GroupFilterBasis.topology /-
 /-- The topological space structure coming from a group filter basis. -/
@@ -223,27 +239,34 @@ theorem nhds_eq (B : GroupFilterBasis G) {x₀ : G} : @nhds G B.topology x₀ =
 #align add_group_filter_basis.nhds_eq AddGroupFilterBasis.nhds_eq
 -/
 
+#print GroupFilterBasis.nhds_one_eq /-
 @[to_additive]
 theorem nhds_one_eq (B : GroupFilterBasis G) :
     @nhds G B.topology (1 : G) = B.toFilterBasis.filterₓ := by rw [B.nhds_eq];
   simp only [N, one_mul]; exact map_id
 #align group_filter_basis.nhds_one_eq GroupFilterBasis.nhds_one_eq
 #align add_group_filter_basis.nhds_zero_eq AddGroupFilterBasis.nhds_zero_eq
+-/
 
+#print GroupFilterBasis.nhds_hasBasis /-
 @[to_additive]
 theorem nhds_hasBasis (B : GroupFilterBasis G) (x₀ : G) :
     HasBasis (@nhds G B.topology x₀) (fun V : Set G => V ∈ B) fun V => (fun y => x₀ * y) '' V := by
   rw [B.nhds_eq]; apply B.has_basis
 #align group_filter_basis.nhds_has_basis GroupFilterBasis.nhds_hasBasis
 #align add_group_filter_basis.nhds_has_basis AddGroupFilterBasis.nhds_hasBasis
+-/
 
+#print GroupFilterBasis.nhds_one_hasBasis /-
 @[to_additive]
 theorem nhds_one_hasBasis (B : GroupFilterBasis G) :
     HasBasis (@nhds G B.topology 1) (fun V : Set G => V ∈ B) id := by rw [B.nhds_one_eq];
   exact B.to_filter_basis.has_basis
 #align group_filter_basis.nhds_one_has_basis GroupFilterBasis.nhds_one_hasBasis
 #align add_group_filter_basis.nhds_zero_has_basis AddGroupFilterBasis.nhds_zero_hasBasis
+-/
 
+#print GroupFilterBasis.mem_nhds_one /-
 @[to_additive]
 theorem mem_nhds_one (B : GroupFilterBasis G) {U : Set G} (hU : U ∈ B) : U ∈ @nhds G B.topology 1 :=
   by
@@ -251,6 +274,7 @@ theorem mem_nhds_one (B : GroupFilterBasis G) {U : Set G} (hU : U ∈ B) : U ∈
   exact ⟨U, hU, rfl.subset⟩
 #align group_filter_basis.mem_nhds_one GroupFilterBasis.mem_nhds_one
 #align add_group_filter_basis.mem_nhds_zero AddGroupFilterBasis.mem_nhds_zero
+-/
 
 #print GroupFilterBasis.isTopologicalGroup /-
 -- See note [lower instance priority]
@@ -306,17 +330,23 @@ variable {R : Type u} [Ring R] (B : RingFilterBasis R)
 instance : Membership (Set R) (RingFilterBasis R) :=
   ⟨fun s B => s ∈ B.sets⟩
 
+#print RingFilterBasis.mul /-
 theorem mul {U : Set R} (hU : U ∈ B) : ∃ V ∈ B, V * V ⊆ U :=
   mul' hU
 #align ring_filter_basis.mul RingFilterBasis.mul
+-/
 
+#print RingFilterBasis.mul_left /-
 theorem mul_left (x₀ : R) {U : Set R} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x => x₀ * x) ⁻¹' U :=
   mul_left' x₀ hU
 #align ring_filter_basis.mul_left RingFilterBasis.mul_left
+-/
 
+#print RingFilterBasis.mul_right /-
 theorem mul_right (x₀ : R) {U : Set R} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x => x * x₀) ⁻¹' U :=
   mul_right' x₀ hU
 #align ring_filter_basis.mul_right RingFilterBasis.mul_right
+-/
 
 #print RingFilterBasis.topology /-
 /-- The topology associated to a ring filter basis.
@@ -382,17 +412,23 @@ instance GroupFilterBasis.hasMem : Membership (Set M) (ModuleFilterBasis R M) :=
 #align module_filter_basis.group_filter_basis.has_mem ModuleFilterBasis.GroupFilterBasis.hasMem
 -/
 
+#print ModuleFilterBasis.smul /-
 theorem smul {U : Set M} (hU : U ∈ B) : ∃ V ∈ 𝓝 (0 : R), ∃ W ∈ B, V • W ⊆ U :=
   B.smul' hU
 #align module_filter_basis.smul ModuleFilterBasis.smul
+-/
 
+#print ModuleFilterBasis.smul_left /-
 theorem smul_left (x₀ : R) {U : Set M} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x => x₀ • x) ⁻¹' U :=
   B.smul_left' x₀ hU
 #align module_filter_basis.smul_left ModuleFilterBasis.smul_left
+-/
 
+#print ModuleFilterBasis.smul_right /-
 theorem smul_right (m₀ : M) {U : Set M} (hU : U ∈ B) : ∀ᶠ x in 𝓝 (0 : R), x • m₀ ∈ U :=
   B.smul_right' m₀ hU
 #align module_filter_basis.smul_right ModuleFilterBasis.smul_right
+-/
 
 /-- If `R` is discrete then the trivial additive group filter basis on any `R`-module is a
 module filter basis. -/
@@ -434,6 +470,7 @@ def topology' {R M : Type _} [CommRing R] {tR : TopologicalSpace R} [AddCommGrou
 #align module_filter_basis.topology' ModuleFilterBasis.topology'
 -/
 
+#print ContinuousSMul.of_basis_zero /-
 /-- A topological add group whith a basis of `𝓝 0` satisfying the axioms of `module_filter_basis`
 is a topological module.
 
@@ -466,6 +503,7 @@ theorem ContinuousSMul.of_basis_zero {ι : Type _} [TopologicalRing R] [Topologi
     rcases hsmul_left x₀ hi with ⟨j, hj, hji⟩
     exact mem_of_superset (h.mem_of_mem hj) hji
 #align has_continuous_smul.of_basis_zero ContinuousSMul.of_basis_zero
+-/
 
 #print ModuleFilterBasis.continuousSMul /-
 /-- If a module is endowed with a topological structure coming from
@@ -481,6 +519,7 @@ instance (priority := 100) continuousSMul [TopologicalRing R] :
 #align module_filter_basis.has_continuous_smul ModuleFilterBasis.continuousSMul
 -/
 
+#print ModuleFilterBasis.ofBases /-
 /-- Build a module filter basis from compatible ring and additive group filter bases. -/
 def ofBases {R M : Type _} [CommRing R] [AddCommGroup M] [Module R M] (BR : RingFilterBasis R)
     (BM : AddGroupFilterBasis M) (smul : ∀ {U}, U ∈ BM → ∃ V ∈ BR, ∃ W ∈ BM, V • W ⊆ U)
@@ -499,6 +538,7 @@ def ofBases {R M : Type _} [CommRing R] [AddCommGroup M] [Module R M] (BR : Ring
       rcases smul_right m₀ U_in with ⟨V, V_in, H⟩
       exact mem_of_superset (BR.to_add_group_filter_basis.mem_nhds_zero V_in) H }
 #align module_filter_basis.of_bases ModuleFilterBasis.ofBases
+-/
 
 end ModuleFilterBasis
 

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

@@ -143,7 +143,7 @@ instance : Inhabited (GroupFilterBasis G) :=
   ⟨by
     refine'
       { sets := {{1}}
-        Nonempty := singleton_nonempty _.. }
+        Nonempty := singleton_nonempty _ .. }
     all_goals simp only [exists_prop, mem_singleton_iff]
     · rintro - - rfl rfl
       use {1}
@@ -202,16 +202,16 @@ theorem nhds_eq (B : GroupFilterBasis G) {x₀ : G} : @nhds G B.topology x₀ =
   by
   rw [TopologicalSpace.nhds_mkOfNhds]
   · intro x U U_in
-    rw [(B.has_basis x).mem_iff] at U_in
+    rw [(B.has_basis x).mem_iff] at U_in 
     rcases U_in with ⟨V, V_in, H⟩
     simpa [mem_pure] using H (mem_image_of_mem _ (GroupFilterBasis.one V_in))
   · intro x U U_in
-    rw [(B.has_basis x).mem_iff] at U_in
+    rw [(B.has_basis x).mem_iff] at U_in 
     rcases U_in with ⟨V, V_in, H⟩
     rcases GroupFilterBasis.mul V_in with ⟨W, W_in, hW⟩
     use (fun y => x * y) '' W, image_mem_map (FilterBasis.mem_filter_of_mem _ W_in)
     constructor
-    · rw [image_subset_iff] at H⊢
+    · rw [image_subset_iff] at H ⊢
       exact ((B.prod_subset_self W_in).trans hW).trans H
     · rintro y ⟨t, tW, rfl⟩
       rw [(B.has_basis _).mem_iff]
@@ -364,7 +364,7 @@ end RingFilterBasis
   `module_filter_basis`. Conversely given a `module_filter_basis` one can define a topology
   compatible with the module structure on `M`.  -/
 structure ModuleFilterBasis (R M : Type _) [CommRing R] [TopologicalSpace R] [AddCommGroup M]
-  [Module R M] extends AddGroupFilterBasis M where
+    [Module R M] extends AddGroupFilterBasis M where
   smul' : ∀ {U}, U ∈ sets → ∃ V ∈ 𝓝 (0 : R), ∃ W ∈ sets, V • W ⊆ U
   smul_left' : ∀ (x₀ : R) {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x => x₀ • x) ⁻¹' U
   smul_right' : ∀ (m₀ : M) {U}, U ∈ sets → ∀ᶠ x in 𝓝 (0 : R), x • m₀ ∈ U
@@ -402,18 +402,18 @@ instance [DiscreteTopology R] : Inhabited (ModuleFilterBasis R M) :=
         default with
       smul' := by
         rintro U (h : U ∈ {{(0 : M)}})
-        rw [mem_singleton_iff] at h
+        rw [mem_singleton_iff] at h 
         use univ, univ_mem, {0}, rfl
         rintro a ⟨x, m, -, hm, rfl⟩
         simp [mem_singleton_iff.1 hm, h]
       smul_left' := by
         rintro x₀ U (h : U ∈ {{(0 : M)}})
-        rw [mem_singleton_iff] at h
+        rw [mem_singleton_iff] at h 
         use {0}, rfl
         simp [h]
       smul_right' := by
         rintro m₀ U (h : U ∈ (0 : Set (Set M)))
-        rw [Set.mem_zero] at h
+        rw [Set.mem_zero] at h 
         simp [h, nhds_discrete] }⟩
 
 #print ModuleFilterBasis.topology /-
@@ -445,8 +445,8 @@ But it turns out it's just easier to get it as a biproduct of the proof, so this
 quality-of-life improvement. -/
 theorem ContinuousSMul.of_basis_zero {ι : Type _} [TopologicalRing R] [TopologicalSpace M]
     [TopologicalAddGroup M] {p : ι → Prop} {b : ι → Set M} (h : HasBasis (𝓝 0) p b)
-    (hsmul : ∀ {i}, p i → ∃ V ∈ 𝓝 (0 : R), ∃ (j : _)(hj : p j), V • b j ⊆ b i)
-    (hsmul_left : ∀ (x₀ : R) {i}, p i → ∃ (j : _)(hj : p j), b j ⊆ (fun x => x₀ • x) ⁻¹' b i)
+    (hsmul : ∀ {i}, p i → ∃ V ∈ 𝓝 (0 : R), ∃ (j : _) (hj : p j), V • b j ⊆ b i)
+    (hsmul_left : ∀ (x₀ : R) {i}, p i → ∃ (j : _) (hj : p j), b j ⊆ (fun x => x₀ • x) ⁻¹' b i)
     (hsmul_right : ∀ (m₀ : M) {i}, p i → ∀ᶠ x in 𝓝 (0 : R), x • m₀ ∈ b i) : ContinuousSMul R M :=
   by
   apply ContinuousSMul.of_nhds_zero

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

@@ -45,7 +45,7 @@ Given a group `G` and a ring `R`:
 
 open Filter Set TopologicalSpace Function
 
-open Topology Filter Pointwise
+open scoped Topology Filter Pointwise
 
 universe u
 

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

@@ -87,12 +87,6 @@ attribute [to_additive] GroupFilterBasis.conj'
 
 attribute [to_additive] GroupFilterBasis.toFilterBasis
 
-/- warning: group_filter_basis_of_comm -> groupFilterBasisOfComm is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : CommGroup.{u1} G] (sets : Set.{u1} (Set.{u1} G)), (Set.Nonempty.{u1} (Set.{u1} G) sets) -> (forall (x : Set.{u1} G) (y : Set.{u1} G), (Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) x sets) -> (Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) y sets) -> (Exists.{succ u1} (Set.{u1} G) (fun (z : Set.{u1} G) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) z sets) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) z sets) => HasSubset.Subset.{u1} (Set.{u1} G) (Set.hasSubset.{u1} G) z (Inter.inter.{u1} (Set.{u1} G) (Set.hasInter.{u1} G) x y))))) -> (forall (U : Set.{u1} G), (Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) U sets) -> (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1)))))))) U)) -> (forall (U : Set.{u1} G), (Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) U sets) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) V sets) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) V sets) => HasSubset.Subset.{u1} (Set.{u1} G) (Set.hasSubset.{u1} G) (HMul.hMul.{u1, u1, u1} (Set.{u1} G) (Set.{u1} G) (Set.{u1} G) (instHMul.{u1} (Set.{u1} G) (Set.mul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))))) V V) U)))) -> (forall (U : Set.{u1} G), (Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) U sets) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) V sets) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) V sets) => HasSubset.Subset.{u1} (Set.{u1} G) (Set.hasSubset.{u1} G) V (Set.preimage.{u1, u1} G G (fun (x : G) => Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))) x) U))))) -> (GroupFilterBasis.{u1} G (CommGroup.toGroup.{u1} G _inst_1))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : CommGroup.{u1} G] (sets : Set.{u1} (Set.{u1} G)), (Set.Nonempty.{u1} (Set.{u1} G) sets) -> (forall (x : Set.{u1} G) (y : Set.{u1} G), (Membership.mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.instMembershipSet.{u1} (Set.{u1} G)) x sets) -> (Membership.mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.instMembershipSet.{u1} (Set.{u1} G)) y sets) -> (Exists.{succ u1} (Set.{u1} G) (fun (z : Set.{u1} G) => And (Membership.mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.instMembershipSet.{u1} (Set.{u1} G)) z sets) (HasSubset.Subset.{u1} (Set.{u1} G) (Set.instHasSubsetSet.{u1} G) z (Inter.inter.{u1} (Set.{u1} G) (Set.instInterSet.{u1} G) x y))))) -> (forall (U : Set.{u1} G), (Membership.mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.instMembershipSet.{u1} (Set.{u1} G)) U sets) -> (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G (CommGroup.toDivisionCommMonoid.{u1} G _inst_1))))))) U)) -> (forall (U : Set.{u1} G), (Membership.mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.instMembershipSet.{u1} (Set.{u1} G)) U sets) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => And (Membership.mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.instMembershipSet.{u1} (Set.{u1} G)) V sets) (HasSubset.Subset.{u1} (Set.{u1} G) (Set.instHasSubsetSet.{u1} G) (HMul.hMul.{u1, u1, u1} (Set.{u1} G) (Set.{u1} G) (Set.{u1} G) (instHMul.{u1} (Set.{u1} G) (Set.mul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))))) V V) U)))) -> (forall (U : Set.{u1} G), (Membership.mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.instMembershipSet.{u1} (Set.{u1} G)) U sets) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => And (Membership.mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.instMembershipSet.{u1} (Set.{u1} G)) V sets) (HasSubset.Subset.{u1} (Set.{u1} G) (Set.instHasSubsetSet.{u1} G) V (Set.preimage.{u1, u1} G G (fun (x : G) => Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G (CommGroup.toDivisionCommMonoid.{u1} G _inst_1))))) x) U))))) -> (GroupFilterBasis.{u1} G (CommGroup.toGroup.{u1} G _inst_1))
-Case conversion may be inaccurate. Consider using '#align group_filter_basis_of_comm groupFilterBasisOfCommₓ'. -/
 /-- `group_filter_basis` constructor in the commutative group case. -/
 @[to_additive "`add_group_filter_basis` constructor in the additive commutative group case."]
 def groupFilterBasisOfComm {G : Type _} [CommGroup G] (sets : Set (Set G))
@@ -117,48 +111,24 @@ variable {G : Type u} [Group G] {B : GroupFilterBasis G}
 instance : Membership (Set G) (GroupFilterBasis G) :=
   ⟨fun s f => s ∈ f.sets⟩
 
-/- warning: group_filter_basis.one -> GroupFilterBasis.one is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {B : GroupFilterBasis.{u1} G _inst_1} {U : Set.{u1} G}, (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) U B) -> (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) U)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {B : GroupFilterBasis.{u1} G _inst_1} {U : Set.{u1} G}, (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) U B) -> (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))))) U)
-Case conversion may be inaccurate. Consider using '#align group_filter_basis.one GroupFilterBasis.oneₓ'. -/
 @[to_additive]
 theorem one {U : Set G} : U ∈ B → (1 : G) ∈ U :=
   GroupFilterBasis.one'
 #align group_filter_basis.one GroupFilterBasis.one
 #align add_group_filter_basis.zero AddGroupFilterBasis.zero
 
-/- warning: group_filter_basis.mul -> GroupFilterBasis.mul is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {B : GroupFilterBasis.{u1} G _inst_1} {U : Set.{u1} G}, (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) => HasSubset.Subset.{u1} (Set.{u1} G) (Set.hasSubset.{u1} G) (HMul.hMul.{u1, u1, u1} (Set.{u1} G) (Set.{u1} G) (Set.{u1} G) (instHMul.{u1} (Set.{u1} G) (Set.mul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) V V) U)))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {B : GroupFilterBasis.{u1} G _inst_1} {U : Set.{u1} G}, (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => And (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) V B) (HasSubset.Subset.{u1} (Set.{u1} G) (Set.instHasSubsetSet.{u1} G) (HMul.hMul.{u1, u1, u1} (Set.{u1} G) (Set.{u1} G) (Set.{u1} G) (instHMul.{u1} (Set.{u1} G) (Set.mul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) V V) U)))
-Case conversion may be inaccurate. Consider using '#align group_filter_basis.mul GroupFilterBasis.mulₓ'. -/
 @[to_additive]
 theorem mul {U : Set G} : U ∈ B → ∃ V ∈ B, V * V ⊆ U :=
   GroupFilterBasis.mul'
 #align group_filter_basis.mul GroupFilterBasis.mul
 #align add_group_filter_basis.add AddGroupFilterBasis.add
 
-/- warning: group_filter_basis.inv -> GroupFilterBasis.inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {B : GroupFilterBasis.{u1} G _inst_1} {U : Set.{u1} G}, (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) => HasSubset.Subset.{u1} (Set.{u1} G) (Set.hasSubset.{u1} G) V (Set.preimage.{u1, u1} G G (fun (x : G) => Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) x) U))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {B : GroupFilterBasis.{u1} G _inst_1} {U : Set.{u1} G}, (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => And (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) V B) (HasSubset.Subset.{u1} (Set.{u1} G) (Set.instHasSubsetSet.{u1} G) V (Set.preimage.{u1, u1} G G (fun (x : G) => Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) x) U))))
-Case conversion may be inaccurate. Consider using '#align group_filter_basis.inv GroupFilterBasis.invₓ'. -/
 @[to_additive]
 theorem inv {U : Set G} : U ∈ B → ∃ V ∈ B, V ⊆ (fun x => x⁻¹) ⁻¹' U :=
   GroupFilterBasis.inv'
 #align group_filter_basis.inv GroupFilterBasis.inv
 #align add_group_filter_basis.neg AddGroupFilterBasis.neg
 
-/- warning: group_filter_basis.conj -> GroupFilterBasis.conj is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {B : GroupFilterBasis.{u1} G _inst_1} (x₀ : G) {U : Set.{u1} G}, (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) => HasSubset.Subset.{u1} (Set.{u1} G) (Set.hasSubset.{u1} G) V (Set.preimage.{u1, u1} G G (fun (x : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x₀ x) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) x₀)) U))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {B : GroupFilterBasis.{u1} G _inst_1} (x₀ : G) {U : Set.{u1} G}, (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => And (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) V B) (HasSubset.Subset.{u1} (Set.{u1} G) (Set.instHasSubsetSet.{u1} G) V (Set.preimage.{u1, u1} G G (fun (x : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x₀ x) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) x₀)) U))))
-Case conversion may be inaccurate. Consider using '#align group_filter_basis.conj GroupFilterBasis.conjₓ'. -/
 @[to_additive]
 theorem conj : ∀ x₀, ∀ {U}, U ∈ B → ∃ V ∈ B, V ⊆ (fun x => x₀ * x * x₀⁻¹) ⁻¹' U :=
   GroupFilterBasis.conj'
@@ -189,12 +159,6 @@ instance : Inhabited (GroupFilterBasis G) :=
       use {1}
       simp⟩
 
-/- warning: group_filter_basis.prod_subset_self -> GroupFilterBasis.prod_subset_self is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1) {U : Set.{u1} G}, (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) U B) -> (HasSubset.Subset.{u1} (Set.{u1} G) (Set.hasSubset.{u1} G) U (HMul.hMul.{u1, u1, u1} (Set.{u1} G) (Set.{u1} G) (Set.{u1} G) (instHMul.{u1} (Set.{u1} G) (Set.mul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) U U))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1) {U : Set.{u1} G}, (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) U B) -> (HasSubset.Subset.{u1} (Set.{u1} G) (Set.instHasSubsetSet.{u1} G) U (HMul.hMul.{u1, u1, u1} (Set.{u1} G) (Set.{u1} G) (Set.{u1} G) (instHMul.{u1} (Set.{u1} G) (Set.mul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) U U))
-Case conversion may be inaccurate. Consider using '#align group_filter_basis.prod_subset_self GroupFilterBasis.prod_subset_selfₓ'. -/
 @[to_additive]
 theorem prod_subset_self (B : GroupFilterBasis G) {U : Set G} (h : U ∈ B) : U ⊆ U * U :=
   fun x x_in => ⟨1, x, one h, x_in, one_mul x⟩
@@ -210,24 +174,12 @@ def N (B : GroupFilterBasis G) : G → Filter G := fun x =>
 #align add_group_filter_basis.N AddGroupFilterBasis.N
 -/
 
-/- warning: group_filter_basis.N_one -> GroupFilterBasis.N_one is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1), Eq.{succ u1} (Filter.{u1} G) (GroupFilterBasis.N.{u1} G _inst_1 B (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))))) (FilterBasis.filter.{u1} G (GroupFilterBasis.toFilterBasis.{u1} G _inst_1 B))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1), Eq.{succ u1} (Filter.{u1} G) (GroupFilterBasis.N.{u1} G _inst_1 B (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1))))))) (FilterBasis.filter.{u1} G (GroupFilterBasis.toFilterBasis.{u1} G _inst_1 B))
-Case conversion may be inaccurate. Consider using '#align group_filter_basis.N_one GroupFilterBasis.N_oneₓ'. -/
 @[simp, to_additive]
 theorem N_one (B : GroupFilterBasis G) : B.N 1 = B.toFilterBasis.filterₓ := by
   simp only [N, one_mul, map_id']
 #align group_filter_basis.N_one GroupFilterBasis.N_one
 #align add_group_filter_basis.N_zero AddGroupFilterBasis.N_zero
 
-/- warning: group_filter_basis.has_basis -> GroupFilterBasis.hasBasis is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1) (x : G), Filter.HasBasis.{u1, succ u1} G (Set.{u1} G) (GroupFilterBasis.N.{u1} G _inst_1 B x) (fun (V : Set.{u1} G) => Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) (fun (V : Set.{u1} G) => Set.image.{u1, u1} G G (fun (y : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x y) V)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1) (x : G), Filter.HasBasis.{u1, succ u1} G (Set.{u1} G) (GroupFilterBasis.N.{u1} G _inst_1 B x) (fun (V : Set.{u1} G) => Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) V B) (fun (V : Set.{u1} G) => Set.image.{u1, u1} G G (fun (y : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x y) V)
-Case conversion may be inaccurate. Consider using '#align group_filter_basis.has_basis GroupFilterBasis.hasBasisₓ'. -/
 @[to_additive]
 protected theorem hasBasis (B : GroupFilterBasis G) (x : G) :
     HasBasis (B.N x) (fun V : Set G => V ∈ B) fun V => (fun y => x * y) '' V :=
@@ -271,12 +223,6 @@ theorem nhds_eq (B : GroupFilterBasis G) {x₀ : G} : @nhds G B.topology x₀ =
 #align add_group_filter_basis.nhds_eq AddGroupFilterBasis.nhds_eq
 -/
 
-/- warning: group_filter_basis.nhds_one_eq -> GroupFilterBasis.nhds_one_eq is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1), Eq.{succ u1} (Filter.{u1} G) (nhds.{u1} G (GroupFilterBasis.topology.{u1} G _inst_1 B) (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))))) (FilterBasis.filter.{u1} G (GroupFilterBasis.toFilterBasis.{u1} G _inst_1 B))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1), Eq.{succ u1} (Filter.{u1} G) (nhds.{u1} G (GroupFilterBasis.topology.{u1} G _inst_1 B) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1))))))) (FilterBasis.filter.{u1} G (GroupFilterBasis.toFilterBasis.{u1} G _inst_1 B))
-Case conversion may be inaccurate. Consider using '#align group_filter_basis.nhds_one_eq GroupFilterBasis.nhds_one_eqₓ'. -/
 @[to_additive]
 theorem nhds_one_eq (B : GroupFilterBasis G) :
     @nhds G B.topology (1 : G) = B.toFilterBasis.filterₓ := by rw [B.nhds_eq];
@@ -284,12 +230,6 @@ theorem nhds_one_eq (B : GroupFilterBasis G) :
 #align group_filter_basis.nhds_one_eq GroupFilterBasis.nhds_one_eq
 #align add_group_filter_basis.nhds_zero_eq AddGroupFilterBasis.nhds_zero_eq
 
-/- warning: group_filter_basis.nhds_has_basis -> GroupFilterBasis.nhds_hasBasis is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1) (x₀ : G), Filter.HasBasis.{u1, succ u1} G (Set.{u1} G) (nhds.{u1} G (GroupFilterBasis.topology.{u1} G _inst_1 B) x₀) (fun (V : Set.{u1} G) => Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) (fun (V : Set.{u1} G) => Set.image.{u1, u1} G G (fun (y : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x₀ y) V)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1) (x₀ : G), Filter.HasBasis.{u1, succ u1} G (Set.{u1} G) (nhds.{u1} G (GroupFilterBasis.topology.{u1} G _inst_1 B) x₀) (fun (V : Set.{u1} G) => Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) V B) (fun (V : Set.{u1} G) => Set.image.{u1, u1} G G (fun (y : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x₀ y) V)
-Case conversion may be inaccurate. Consider using '#align group_filter_basis.nhds_has_basis GroupFilterBasis.nhds_hasBasisₓ'. -/
 @[to_additive]
 theorem nhds_hasBasis (B : GroupFilterBasis G) (x₀ : G) :
     HasBasis (@nhds G B.topology x₀) (fun V : Set G => V ∈ B) fun V => (fun y => x₀ * y) '' V := by
@@ -297,12 +237,6 @@ theorem nhds_hasBasis (B : GroupFilterBasis G) (x₀ : G) :
 #align group_filter_basis.nhds_has_basis GroupFilterBasis.nhds_hasBasis
 #align add_group_filter_basis.nhds_has_basis AddGroupFilterBasis.nhds_hasBasis
 
-/- warning: group_filter_basis.nhds_one_has_basis -> GroupFilterBasis.nhds_one_hasBasis is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1), Filter.HasBasis.{u1, succ u1} G (Set.{u1} G) (nhds.{u1} G (GroupFilterBasis.topology.{u1} G _inst_1 B) (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))))) (fun (V : Set.{u1} G) => Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) (id.{succ u1} (Set.{u1} G))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1), Filter.HasBasis.{u1, succ u1} G (Set.{u1} G) (nhds.{u1} G (GroupFilterBasis.topology.{u1} G _inst_1 B) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1))))))) (fun (V : Set.{u1} G) => Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) V B) (id.{succ u1} (Set.{u1} G))
-Case conversion may be inaccurate. Consider using '#align group_filter_basis.nhds_one_has_basis GroupFilterBasis.nhds_one_hasBasisₓ'. -/
 @[to_additive]
 theorem nhds_one_hasBasis (B : GroupFilterBasis G) :
     HasBasis (@nhds G B.topology 1) (fun V : Set G => V ∈ B) id := by rw [B.nhds_one_eq];
@@ -310,12 +244,6 @@ theorem nhds_one_hasBasis (B : GroupFilterBasis G) :
 #align group_filter_basis.nhds_one_has_basis GroupFilterBasis.nhds_one_hasBasis
 #align add_group_filter_basis.nhds_zero_has_basis AddGroupFilterBasis.nhds_zero_hasBasis
 
-/- warning: group_filter_basis.mem_nhds_one -> GroupFilterBasis.mem_nhds_one is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1) {U : Set.{u1} G}, (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) U B) -> (Membership.Mem.{u1, u1} (Set.{u1} G) (Filter.{u1} G) (Filter.hasMem.{u1} G) U (nhds.{u1} G (GroupFilterBasis.topology.{u1} G _inst_1 B) (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1) {U : Set.{u1} G}, (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) U B) -> (Membership.mem.{u1, u1} (Set.{u1} G) (Filter.{u1} G) (instMembershipSetFilter.{u1} G) U (nhds.{u1} G (GroupFilterBasis.topology.{u1} G _inst_1 B) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align group_filter_basis.mem_nhds_one GroupFilterBasis.mem_nhds_oneₓ'. -/
 @[to_additive]
 theorem mem_nhds_one (B : GroupFilterBasis G) {U : Set G} (hU : U ∈ B) : U ∈ @nhds G B.topology 1 :=
   by
@@ -378,32 +306,14 @@ variable {R : Type u} [Ring R] (B : RingFilterBasis R)
 instance : Membership (Set R) (RingFilterBasis R) :=
   ⟨fun s B => s ∈ B.sets⟩
 
-/- warning: ring_filter_basis.mul -> RingFilterBasis.mul is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] (B : RingFilterBasis.{u1} R _inst_1) {U : Set.{u1} R}, (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) V B) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) V B) => HasSubset.Subset.{u1} (Set.{u1} R) (Set.hasSubset.{u1} R) (HMul.hMul.{u1, u1, u1} (Set.{u1} R) (Set.{u1} R) (Set.{u1} R) (instHMul.{u1} (Set.{u1} R) (Set.mul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_1)))) V V) U)))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] (B : RingFilterBasis.{u1} R _inst_1) {U : Set.{u1} R}, (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R _inst_1) V B) (HasSubset.Subset.{u1} (Set.{u1} R) (Set.instHasSubsetSet.{u1} R) (HMul.hMul.{u1, u1, u1} (Set.{u1} R) (Set.{u1} R) (Set.{u1} R) (instHMul.{u1} (Set.{u1} R) (Set.mul.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) V V) U)))
-Case conversion may be inaccurate. Consider using '#align ring_filter_basis.mul RingFilterBasis.mulₓ'. -/
 theorem mul {U : Set R} (hU : U ∈ B) : ∃ V ∈ B, V * V ⊆ U :=
   mul' hU
 #align ring_filter_basis.mul RingFilterBasis.mul
 
-/- warning: ring_filter_basis.mul_left -> RingFilterBasis.mul_left is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] (B : RingFilterBasis.{u1} R _inst_1) (x₀ : R) {U : Set.{u1} R}, (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) V B) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) V B) => HasSubset.Subset.{u1} (Set.{u1} R) (Set.hasSubset.{u1} R) V (Set.preimage.{u1, u1} R R (fun (x : R) => HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_1))) x₀ x) U))))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] (B : RingFilterBasis.{u1} R _inst_1) (x₀ : R) {U : Set.{u1} R}, (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R _inst_1) V B) (HasSubset.Subset.{u1} (Set.{u1} R) (Set.instHasSubsetSet.{u1} R) V (Set.preimage.{u1, u1} R R (fun (x : R) => HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))) x₀ x) U))))
-Case conversion may be inaccurate. Consider using '#align ring_filter_basis.mul_left RingFilterBasis.mul_leftₓ'. -/
 theorem mul_left (x₀ : R) {U : Set R} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x => x₀ * x) ⁻¹' U :=
   mul_left' x₀ hU
 #align ring_filter_basis.mul_left RingFilterBasis.mul_left
 
-/- warning: ring_filter_basis.mul_right -> RingFilterBasis.mul_right is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] (B : RingFilterBasis.{u1} R _inst_1) (x₀ : R) {U : Set.{u1} R}, (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) V B) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) V B) => HasSubset.Subset.{u1} (Set.{u1} R) (Set.hasSubset.{u1} R) V (Set.preimage.{u1, u1} R R (fun (x : R) => HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_1))) x x₀) U))))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] (B : RingFilterBasis.{u1} R _inst_1) (x₀ : R) {U : Set.{u1} R}, (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R _inst_1) V B) (HasSubset.Subset.{u1} (Set.{u1} R) (Set.instHasSubsetSet.{u1} R) V (Set.preimage.{u1, u1} R R (fun (x : R) => HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))) x x₀) U))))
-Case conversion may be inaccurate. Consider using '#align ring_filter_basis.mul_right RingFilterBasis.mul_rightₓ'. -/
 theorem mul_right (x₀ : R) {U : Set R} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x => x * x₀) ⁻¹' U :=
   mul_right' x₀ hU
 #align ring_filter_basis.mul_right RingFilterBasis.mul_right
@@ -472,26 +382,14 @@ instance GroupFilterBasis.hasMem : Membership (Set M) (ModuleFilterBasis R M) :=
 #align module_filter_basis.group_filter_basis.has_mem ModuleFilterBasis.GroupFilterBasis.hasMem
 -/
 
-/- warning: module_filter_basis.smul -> ModuleFilterBasis.smul is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align module_filter_basis.smul ModuleFilterBasis.smulₓ'. -/
 theorem smul {U : Set M} (hU : U ∈ B) : ∃ V ∈ 𝓝 (0 : R), ∃ W ∈ B, V • W ⊆ U :=
   B.smul' hU
 #align module_filter_basis.smul ModuleFilterBasis.smul
 
-/- warning: module_filter_basis.smul_left -> ModuleFilterBasis.smul_left is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align module_filter_basis.smul_left ModuleFilterBasis.smul_leftₓ'. -/
 theorem smul_left (x₀ : R) {U : Set M} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x => x₀ • x) ⁻¹' U :=
   B.smul_left' x₀ hU
 #align module_filter_basis.smul_left ModuleFilterBasis.smul_left
 
-/- warning: module_filter_basis.smul_right -> ModuleFilterBasis.smul_right is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (m₀ : M) {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Filter.Eventually.{u1} R (fun (x : R) => Membership.Mem.{u2, u2} M (Set.{u2} M) (Set.hasMem.{u2} M) (SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))) x m₀) U) (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1)))))))))))
-but is expected to have type
-  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (m₀ : M) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Filter.Eventually.{u1} R (fun (x : R) => Membership.mem.{u2, u2} M (Set.{u2} M) (Set.instMembershipSet.{u2} M) (HSMul.hSMul.{u1, u2, u2} R M M (instHSMul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (Module.toMulActionWithZero.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4))))) x m₀) U) (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align module_filter_basis.smul_right ModuleFilterBasis.smul_rightₓ'. -/
 theorem smul_right (m₀ : M) {U : Set M} (hU : U ∈ B) : ∀ᶠ x in 𝓝 (0 : R), x • m₀ ∈ U :=
   B.smul_right' m₀ hU
 #align module_filter_basis.smul_right ModuleFilterBasis.smul_right
@@ -536,9 +434,6 @@ def topology' {R M : Type _} [CommRing R] {tR : TopologicalSpace R} [AddCommGrou
 #align module_filter_basis.topology' ModuleFilterBasis.topology'
 -/
 
-/- warning: has_continuous_smul.of_basis_zero -> ContinuousSMul.of_basis_zero is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align has_continuous_smul.of_basis_zero ContinuousSMul.of_basis_zeroₓ'. -/
 /-- A topological add group whith a basis of `𝓝 0` satisfying the axioms of `module_filter_basis`
 is a topological module.
 
@@ -586,9 +481,6 @@ instance (priority := 100) continuousSMul [TopologicalRing R] :
 #align module_filter_basis.has_continuous_smul ModuleFilterBasis.continuousSMul
 -/
 
-/- warning: module_filter_basis.of_bases -> ModuleFilterBasis.ofBases is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align module_filter_basis.of_bases ModuleFilterBasis.ofBasesₓ'. -/
 /-- Build a module filter basis from compatible ring and additive group filter bases. -/
 def ofBases {R M : Type _} [CommRing R] [AddCommGroup M] [Module R M] (BR : RingFilterBasis R)
     (BM : AddGroupFilterBasis M) (smul : ∀ {U}, U ∈ BM → ∃ V ∈ BR, ∃ W ∈ BM, V • W ⊆ U)

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

@@ -264,8 +264,7 @@ theorem nhds_eq (B : GroupFilterBasis G) {x₀ : G} : @nhds G B.topology x₀ =
     · rintro y ⟨t, tW, rfl⟩
       rw [(B.has_basis _).mem_iff]
       use W, W_in
-      apply subset.trans _ H
-      clear H
+      apply subset.trans _ H; clear H
       rintro z ⟨w, wW, rfl⟩
       exact ⟨t * w, hW (mul_mem_mul tW wW), by simp [mul_assoc]⟩
 #align group_filter_basis.nhds_eq GroupFilterBasis.nhds_eq
@@ -280,11 +279,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align group_filter_basis.nhds_one_eq GroupFilterBasis.nhds_one_eqₓ'. -/
 @[to_additive]
 theorem nhds_one_eq (B : GroupFilterBasis G) :
-    @nhds G B.topology (1 : G) = B.toFilterBasis.filterₓ :=
-  by
-  rw [B.nhds_eq]
-  simp only [N, one_mul]
-  exact map_id
+    @nhds G B.topology (1 : G) = B.toFilterBasis.filterₓ := by rw [B.nhds_eq];
+  simp only [N, one_mul]; exact map_id
 #align group_filter_basis.nhds_one_eq GroupFilterBasis.nhds_one_eq
 #align add_group_filter_basis.nhds_zero_eq AddGroupFilterBasis.nhds_zero_eq
 
@@ -296,10 +292,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align group_filter_basis.nhds_has_basis GroupFilterBasis.nhds_hasBasisₓ'. -/
 @[to_additive]
 theorem nhds_hasBasis (B : GroupFilterBasis G) (x₀ : G) :
-    HasBasis (@nhds G B.topology x₀) (fun V : Set G => V ∈ B) fun V => (fun y => x₀ * y) '' V :=
-  by
-  rw [B.nhds_eq]
-  apply B.has_basis
+    HasBasis (@nhds G B.topology x₀) (fun V : Set G => V ∈ B) fun V => (fun y => x₀ * y) '' V := by
+  rw [B.nhds_eq]; apply B.has_basis
 #align group_filter_basis.nhds_has_basis GroupFilterBasis.nhds_hasBasis
 #align add_group_filter_basis.nhds_has_basis AddGroupFilterBasis.nhds_hasBasis
 
@@ -311,9 +305,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align group_filter_basis.nhds_one_has_basis GroupFilterBasis.nhds_one_hasBasisₓ'. -/
 @[to_additive]
 theorem nhds_one_hasBasis (B : GroupFilterBasis G) :
-    HasBasis (@nhds G B.topology 1) (fun V : Set G => V ∈ B) id :=
-  by
-  rw [B.nhds_one_eq]
+    HasBasis (@nhds G B.topology 1) (fun V : Set G => V ∈ B) id := by rw [B.nhds_one_eq];
   exact B.to_filter_basis.has_basis
 #align group_filter_basis.nhds_one_has_basis GroupFilterBasis.nhds_one_hasBasis
 #align add_group_filter_basis.nhds_zero_has_basis AddGroupFilterBasis.nhds_zero_hasBasis

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

@@ -481,20 +481,14 @@ instance GroupFilterBasis.hasMem : Membership (Set M) (ModuleFilterBasis R M) :=
 -/
 
 /- warning: module_filter_basis.smul -> ModuleFilterBasis.smul is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (Filter.{u1} R) (Filter.hasMem.{u1} R) V (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1))))))))))) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (Filter.{u1} R) (Filter.hasMem.{u1} R) V (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1))))))))))) => Exists.{succ u2} (Set.{u2} M) (fun (W : Set.{u2} M) => Exists.{0} (Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) W B) (fun (H : Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) W B) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) (SMul.smul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4))))) V W) U)))))
-but is expected to have type
-  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (Filter.{u1} R) (instMembershipSetFilter.{u1} R) V (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))))) (Exists.{succ u2} (Set.{u2} M) (fun (W : Set.{u2} M) => And (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) W B) (HasSubset.Subset.{u2} (Set.{u2} M) (Set.instHasSubsetSet.{u2} M) (HSMul.hSMul.{u1, u2, u2} (Set.{u1} R) (Set.{u2} M) (Set.{u2} M) (instHSMul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (Module.toMulActionWithZero.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))))) V W) U)))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align module_filter_basis.smul ModuleFilterBasis.smulₓ'. -/
 theorem smul {U : Set M} (hU : U ∈ B) : ∃ V ∈ 𝓝 (0 : R), ∃ W ∈ B, V • W ⊆ U :=
   B.smul' hU
 #align module_filter_basis.smul ModuleFilterBasis.smul
 
 /- warning: module_filter_basis.smul_left -> ModuleFilterBasis.smul_left is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (x₀ : R) {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Exists.{succ u2} (Set.{u2} M) (fun (V : Set.{u2} M) => Exists.{0} (Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) V B) (fun (H : Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) V B) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) V (Set.preimage.{u2, u2} M M (fun (x : M) => SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))) x₀ x) U))))
-but is expected to have type
-  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (x₀ : R) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Exists.{succ u2} (Set.{u2} M) (fun (V : Set.{u2} M) => And (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) V B) (HasSubset.Subset.{u2} (Set.{u2} M) (Set.instHasSubsetSet.{u2} M) V (Set.preimage.{u2, u2} M M (fun (x : M) => HSMul.hSMul.{u1, u2, u2} R M M (instHSMul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (Module.toMulActionWithZero.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4))))) x₀ x) U))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align module_filter_basis.smul_left ModuleFilterBasis.smul_leftₓ'. -/
 theorem smul_left (x₀ : R) {U : Set M} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x => x₀ • x) ⁻¹' U :=
   B.smul_left' x₀ hU
@@ -551,10 +545,7 @@ def topology' {R M : Type _} [CommRing R] {tR : TopologicalSpace R} [AddCommGrou
 -/
 
 /- warning: has_continuous_smul.of_basis_zero -> ContinuousSMul.of_basis_zero is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] {ι : Type.{u3}} [_inst_5 : TopologicalRing.{u1} R _inst_2 (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1)))] [_inst_6 : TopologicalSpace.{u2} M] [_inst_7 : TopologicalAddGroup.{u2} M _inst_6 (AddCommGroup.toAddGroup.{u2} M _inst_3)] {p : ι -> Prop} {b : ι -> (Set.{u2} M)}, (Filter.HasBasis.{u2, succ u3} M ι (nhds.{u2} M _inst_6 (OfNat.ofNat.{u2} M 0 (OfNat.mk.{u2} M 0 (Zero.zero.{u2} M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_3))))))))) p b) -> (forall {i : ι}, (p i) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (Filter.{u1} R) (Filter.hasMem.{u1} R) V (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1))))))))))) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (Filter.{u1} R) (Filter.hasMem.{u1} R) V (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1))))))))))) => Exists.{succ u3} ι (fun (j : ι) => Exists.{0} (p j) (fun (hj : p j) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) (SMul.smul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4))))) V (b j)) (b i))))))) -> (forall (x₀ : R) {i : ι}, (p i) -> (Exists.{succ u3} ι (fun (j : ι) => Exists.{0} (p j) (fun (hj : p j) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) (b j) (Set.preimage.{u2, u2} M M (fun (x : M) => SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))) x₀ x) (b i)))))) -> (forall (m₀ : M) {i : ι}, (p i) -> (Filter.Eventually.{u1} R (fun (x : R) => Membership.Mem.{u2, u2} M (Set.{u2} M) (Set.hasMem.{u2} M) (SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))) x m₀) (b i)) (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1)))))))))))) -> (ContinuousSMul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))) _inst_2 _inst_6)
-but is expected to have type
-  forall {R : Type.{u2}} {M : Type.{u1}} [_inst_1 : CommRing.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : AddCommGroup.{u1} M] [_inst_4 : Module.{u2, u1} R M (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3)] {ι : Type.{u3}} [_inst_5 : TopologicalRing.{u2} R _inst_2 (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))] [_inst_6 : TopologicalSpace.{u1} M] [_inst_7 : TopologicalAddGroup.{u1} M _inst_6 (AddCommGroup.toAddGroup.{u1} M _inst_3)] {p : ι -> Prop} {b : ι -> (Set.{u1} M)}, (Filter.HasBasis.{u1, succ u3} M ι (nhds.{u1} M _inst_6 (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3)))))))) p b) -> (forall {i : ι}, (p i) -> (Exists.{succ u2} (Set.{u2} R) (fun (V : Set.{u2} R) => And (Membership.mem.{u2, u2} (Set.{u2} R) (Filter.{u2} R) (instMembershipSetFilter.{u2} R) V (nhds.{u2} R _inst_2 (OfNat.ofNat.{u2} R 0 (Zero.toOfNat0.{u2} R (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))))) (Exists.{succ u3} ι (fun (j : ι) => Exists.{0} (p j) (fun (x._@.Mathlib.Topology.Algebra.FilterBasis._hyg.3702 : p j) => HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) (HSMul.hSMul.{u2, u1, u1} (Set.{u2} R) (Set.{u1} M) (Set.{u1} M) (instHSMul.{u2, u1} (Set.{u2} R) (Set.{u1} M) (Set.smul.{u2, u1} R M (SMulZeroClass.toSMul.{u2, u1} R M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u2, u1} R M (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u2, u1} R M (Semiring.toMonoidWithZero.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (Module.toMulActionWithZero.{u2, u1} R M (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3) _inst_4)))))) V (b j)) (b i))))))) -> (forall (x₀ : R) {i : ι}, (p i) -> (Exists.{succ u3} ι (fun (j : ι) => Exists.{0} (p j) (fun (hj : p j) => HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) (b j) (Set.preimage.{u1, u1} M M (fun (x : M) => HSMul.hSMul.{u2, u1, u1} R M M (instHSMul.{u2, u1} R M (SMulZeroClass.toSMul.{u2, u1} R M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u2, u1} R M (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u2, u1} R M (Semiring.toMonoidWithZero.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (Module.toMulActionWithZero.{u2, u1} R M (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3) _inst_4))))) x₀ x) (b i)))))) -> (forall (m₀ : M) {i : ι}, (p i) -> (Filter.Eventually.{u2} R (fun (x : R) => Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (HSMul.hSMul.{u2, u1, u1} R M M (instHSMul.{u2, u1} R M (SMulZeroClass.toSMul.{u2, u1} R M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u2, u1} R M (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u2, u1} R M (Semiring.toMonoidWithZero.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (Module.toMulActionWithZero.{u2, u1} R M (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3) _inst_4))))) x m₀) (b i)) (nhds.{u2} R _inst_2 (OfNat.ofNat.{u2} R 0 (Zero.toOfNat0.{u2} R (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))))))) -> (ContinuousSMul.{u2, u1} R M (SMulZeroClass.toSMul.{u2, u1} R M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u2, u1} R M (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u2, u1} R M (Semiring.toMonoidWithZero.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (Module.toMulActionWithZero.{u2, u1} R M (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3) _inst_4)))) _inst_2 _inst_6)
+<too large>
 Case conversion may be inaccurate. Consider using '#align has_continuous_smul.of_basis_zero ContinuousSMul.of_basis_zeroₓ'. -/
 /-- A topological add group whith a basis of `𝓝 0` satisfying the axioms of `module_filter_basis`
 is a topological module.
@@ -604,10 +595,7 @@ instance (priority := 100) continuousSMul [TopologicalRing R] :
 -/
 
 /- warning: module_filter_basis.of_bases -> ModuleFilterBasis.ofBases is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_5 : CommRing.{u1} R] [_inst_6 : AddCommGroup.{u2} M] [_inst_7 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)] (BR : RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (BM : AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)), (forall {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.hasMem.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.hasMem.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) => Exists.{succ u2} (Set.{u2} M) (fun (W : Set.{u2} M) => Exists.{0} (Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) W BM) (fun (H : Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) W BM) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) (SMul.smul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7))))) V W) U)))))) -> (forall (x₀ : R) {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u2} (Set.{u2} M) (fun (V : Set.{u2} M) => Exists.{0} (Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) V BM) (fun (H : Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) V BM) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) V (Set.preimage.{u2, u2} M M (fun (x : M) => SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7)))) x₀ x) U))))) -> (forall (m₀ : M) {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.hasMem.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.hasMem.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) => HasSubset.Subset.{u1} (Set.{u1} R) (Set.hasSubset.{u1} R) V (Set.preimage.{u1, u2} R M (fun (x : R) => SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7)))) x m₀) U))))) -> (ModuleFilterBasis.{u1, u2} R M _inst_5 (RingFilterBasis.topology.{u1} R (CommRing.toRing.{u1} R _inst_5) BR) _inst_6 _inst_7)
-but is expected to have type
-  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_5 : CommRing.{u1} R] [_inst_6 : AddCommGroup.{u2} M] [_inst_7 : Module.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)] (BR : RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (BM : AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)), (forall {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) (Exists.{succ u2} (Set.{u2} M) (fun (W : Set.{u2} M) => And (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) W BM) (HasSubset.Subset.{u2} (Set.{u2} M) (Set.instHasSubsetSet.{u2} M) (HSMul.hSMul.{u1, u2, u2} (Set.{u1} R) (Set.{u2} M) (Set.{u2} M) (instHSMul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (Module.toMulActionWithZero.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7)))))) V W) U)))))) -> (forall (x₀ : R) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u2} (Set.{u2} M) (fun (V : Set.{u2} M) => And (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) V BM) (HasSubset.Subset.{u2} (Set.{u2} M) (Set.instHasSubsetSet.{u2} M) V (Set.preimage.{u2, u2} M M (fun (x : M) => HSMul.hSMul.{u1, u2, u2} R M M (instHSMul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (Module.toMulActionWithZero.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7))))) x₀ x) U))))) -> (forall (m₀ : M) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) (HasSubset.Subset.{u1} (Set.{u1} R) (Set.instHasSubsetSet.{u1} R) V (Set.preimage.{u1, u2} R M (fun (x : R) => HSMul.hSMul.{u1, u2, u2} R M M (instHSMul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (Module.toMulActionWithZero.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7))))) x m₀) U))))) -> (ModuleFilterBasis.{u1, u2} R M _inst_5 (RingFilterBasis.topology.{u1} R (CommRing.toRing.{u1} R _inst_5) BR) _inst_6 _inst_7)
+<too large>
 Case conversion may be inaccurate. Consider using '#align module_filter_basis.of_bases ModuleFilterBasis.ofBasesₓ'. -/
 /-- Build a module filter basis from compatible ring and additive group filter bases. -/
 def ofBases {R M : Type _} [CommRing R] [AddCommGroup M] [Module R M] (BR : RingFilterBasis R)

mathlib commit https://github.com/leanprover-community/mathlib/commit/08e1d8d4d989df3a6df86f385e9053ec8a372cc1

@@ -484,7 +484,7 @@ instance GroupFilterBasis.hasMem : Membership (Set M) (ModuleFilterBasis R M) :=
 lean 3 declaration is
   forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (Filter.{u1} R) (Filter.hasMem.{u1} R) V (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1))))))))))) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (Filter.{u1} R) (Filter.hasMem.{u1} R) V (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1))))))))))) => Exists.{succ u2} (Set.{u2} M) (fun (W : Set.{u2} M) => Exists.{0} (Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) W B) (fun (H : Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) W B) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) (SMul.smul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4))))) V W) U)))))
 but is expected to have type
-  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (Filter.{u1} R) (instMembershipSetFilter.{u1} R) V (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))))) (Exists.{succ u2} (Set.{u2} M) (fun (W : Set.{u2} M) => And (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) W B) (HasSubset.Subset.{u2} (Set.{u2} M) (Set.instHasSubsetSet.{u2} M) (HSMul.hSMul.{u1, u2, u2} (Set.{u1} R) (Set.{u2} M) (Set.{u2} M) (instHSMul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))))) V W) U)))))
+  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (Filter.{u1} R) (instMembershipSetFilter.{u1} R) V (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))))) (Exists.{succ u2} (Set.{u2} M) (fun (W : Set.{u2} M) => And (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) W B) (HasSubset.Subset.{u2} (Set.{u2} M) (Set.instHasSubsetSet.{u2} M) (HSMul.hSMul.{u1, u2, u2} (Set.{u1} R) (Set.{u2} M) (Set.{u2} M) (instHSMul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (Module.toMulActionWithZero.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))))) V W) U)))))
 Case conversion may be inaccurate. Consider using '#align module_filter_basis.smul ModuleFilterBasis.smulₓ'. -/
 theorem smul {U : Set M} (hU : U ∈ B) : ∃ V ∈ 𝓝 (0 : R), ∃ W ∈ B, V • W ⊆ U :=
   B.smul' hU
@@ -494,7 +494,7 @@ theorem smul {U : Set M} (hU : U ∈ B) : ∃ V ∈ 𝓝 (0 : R), ∃ W ∈ B, V
 lean 3 declaration is
   forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (x₀ : R) {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Exists.{succ u2} (Set.{u2} M) (fun (V : Set.{u2} M) => Exists.{0} (Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) V B) (fun (H : Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) V B) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) V (Set.preimage.{u2, u2} M M (fun (x : M) => SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))) x₀ x) U))))
 but is expected to have type
-  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (x₀ : R) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Exists.{succ u2} (Set.{u2} M) (fun (V : Set.{u2} M) => And (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) V B) (HasSubset.Subset.{u2} (Set.{u2} M) (Set.instHasSubsetSet.{u2} M) V (Set.preimage.{u2, u2} M M (fun (x : M) => HSMul.hSMul.{u1, u2, u2} R M M (instHSMul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4))))) x₀ x) U))))
+  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (x₀ : R) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Exists.{succ u2} (Set.{u2} M) (fun (V : Set.{u2} M) => And (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) V B) (HasSubset.Subset.{u2} (Set.{u2} M) (Set.instHasSubsetSet.{u2} M) V (Set.preimage.{u2, u2} M M (fun (x : M) => HSMul.hSMul.{u1, u2, u2} R M M (instHSMul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (Module.toMulActionWithZero.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4))))) x₀ x) U))))
 Case conversion may be inaccurate. Consider using '#align module_filter_basis.smul_left ModuleFilterBasis.smul_leftₓ'. -/
 theorem smul_left (x₀ : R) {U : Set M} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x => x₀ • x) ⁻¹' U :=
   B.smul_left' x₀ hU
@@ -504,7 +504,7 @@ theorem smul_left (x₀ : R) {U : Set M} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fu
 lean 3 declaration is
   forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (m₀ : M) {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Filter.Eventually.{u1} R (fun (x : R) => Membership.Mem.{u2, u2} M (Set.{u2} M) (Set.hasMem.{u2} M) (SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))) x m₀) U) (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1)))))))))))
 but is expected to have type
-  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (m₀ : M) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Filter.Eventually.{u1} R (fun (x : R) => Membership.mem.{u2, u2} M (Set.{u2} M) (Set.instMembershipSet.{u2} M) (HSMul.hSMul.{u1, u2, u2} R M M (instHSMul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4))))) x m₀) U) (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))))
+  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (m₀ : M) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Filter.Eventually.{u1} R (fun (x : R) => Membership.mem.{u2, u2} M (Set.{u2} M) (Set.instMembershipSet.{u2} M) (HSMul.hSMul.{u1, u2, u2} R M M (instHSMul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (Module.toMulActionWithZero.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4))))) x m₀) U) (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))))
 Case conversion may be inaccurate. Consider using '#align module_filter_basis.smul_right ModuleFilterBasis.smul_rightₓ'. -/
 theorem smul_right (m₀ : M) {U : Set M} (hU : U ∈ B) : ∀ᶠ x in 𝓝 (0 : R), x • m₀ ∈ U :=
   B.smul_right' m₀ hU
@@ -554,7 +554,7 @@ def topology' {R M : Type _} [CommRing R] {tR : TopologicalSpace R} [AddCommGrou
 lean 3 declaration is
   forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] {ι : Type.{u3}} [_inst_5 : TopologicalRing.{u1} R _inst_2 (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1)))] [_inst_6 : TopologicalSpace.{u2} M] [_inst_7 : TopologicalAddGroup.{u2} M _inst_6 (AddCommGroup.toAddGroup.{u2} M _inst_3)] {p : ι -> Prop} {b : ι -> (Set.{u2} M)}, (Filter.HasBasis.{u2, succ u3} M ι (nhds.{u2} M _inst_6 (OfNat.ofNat.{u2} M 0 (OfNat.mk.{u2} M 0 (Zero.zero.{u2} M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_3))))))))) p b) -> (forall {i : ι}, (p i) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (Filter.{u1} R) (Filter.hasMem.{u1} R) V (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1))))))))))) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (Filter.{u1} R) (Filter.hasMem.{u1} R) V (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1))))))))))) => Exists.{succ u3} ι (fun (j : ι) => Exists.{0} (p j) (fun (hj : p j) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) (SMul.smul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4))))) V (b j)) (b i))))))) -> (forall (x₀ : R) {i : ι}, (p i) -> (Exists.{succ u3} ι (fun (j : ι) => Exists.{0} (p j) (fun (hj : p j) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) (b j) (Set.preimage.{u2, u2} M M (fun (x : M) => SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))) x₀ x) (b i)))))) -> (forall (m₀ : M) {i : ι}, (p i) -> (Filter.Eventually.{u1} R (fun (x : R) => Membership.Mem.{u2, u2} M (Set.{u2} M) (Set.hasMem.{u2} M) (SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))) x m₀) (b i)) (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1)))))))))))) -> (ContinuousSMul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))) _inst_2 _inst_6)
 but is expected to have type
-  forall {R : Type.{u2}} {M : Type.{u1}} [_inst_1 : CommRing.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : AddCommGroup.{u1} M] [_inst_4 : Module.{u2, u1} R M (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3)] {ι : Type.{u3}} [_inst_5 : TopologicalRing.{u2} R _inst_2 (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))] [_inst_6 : TopologicalSpace.{u1} M] [_inst_7 : TopologicalAddGroup.{u1} M _inst_6 (AddCommGroup.toAddGroup.{u1} M _inst_3)] {p : ι -> Prop} {b : ι -> (Set.{u1} M)}, (Filter.HasBasis.{u1, succ u3} M ι (nhds.{u1} M _inst_6 (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3)))))))) p b) -> (forall {i : ι}, (p i) -> (Exists.{succ u2} (Set.{u2} R) (fun (V : Set.{u2} R) => And (Membership.mem.{u2, u2} (Set.{u2} R) (Filter.{u2} R) (instMembershipSetFilter.{u2} R) V (nhds.{u2} R _inst_2 (OfNat.ofNat.{u2} R 0 (Zero.toOfNat0.{u2} R (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))))) (Exists.{succ u3} ι (fun (j : ι) => Exists.{0} (p j) (fun (x._@.Mathlib.Topology.Algebra.FilterBasis._hyg.3702 : p j) => HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) (HSMul.hSMul.{u2, u1, u1} (Set.{u2} R) (Set.{u1} M) (Set.{u1} M) (instHSMul.{u2, u1} (Set.{u2} R) (Set.{u1} M) (Set.smul.{u2, u1} R M (SMulZeroClass.toSMul.{u2, u1} R M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u2, u1} R M (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u2, u1} R M (Semiring.toMonoidWithZero.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (Module.toMulActionWithZero.{u2, u1} R M (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3) _inst_4)))))) V (b j)) (b i))))))) -> (forall (x₀ : R) {i : ι}, (p i) -> (Exists.{succ u3} ι (fun (j : ι) => Exists.{0} (p j) (fun (hj : p j) => HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) (b j) (Set.preimage.{u1, u1} M M (fun (x : M) => HSMul.hSMul.{u2, u1, u1} R M M (instHSMul.{u2, u1} R M (SMulZeroClass.toSMul.{u2, u1} R M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u2, u1} R M (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u2, u1} R M (Semiring.toMonoidWithZero.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (Module.toMulActionWithZero.{u2, u1} R M (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3) _inst_4))))) x₀ x) (b i)))))) -> (forall (m₀ : M) {i : ι}, (p i) -> (Filter.Eventually.{u2} R (fun (x : R) => Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (HSMul.hSMul.{u2, u1, u1} R M M (instHSMul.{u2, u1} R M (SMulZeroClass.toSMul.{u2, u1} R M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u2, u1} R M (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u2, u1} R M (Semiring.toMonoidWithZero.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (Module.toMulActionWithZero.{u2, u1} R M (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3) _inst_4))))) x m₀) (b i)) (nhds.{u2} R _inst_2 (OfNat.ofNat.{u2} R 0 (Zero.toOfNat0.{u2} R (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))))))) -> (ContinuousSMul.{u2, u1} R M (SMulZeroClass.toSMul.{u2, u1} R M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u2, u1} R M (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u2, u1} R M (Semiring.toMonoidWithZero.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (Module.toMulActionWithZero.{u2, u1} R M (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3) _inst_4)))) _inst_2 _inst_6)
+  forall {R : Type.{u2}} {M : Type.{u1}} [_inst_1 : CommRing.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : AddCommGroup.{u1} M] [_inst_4 : Module.{u2, u1} R M (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3)] {ι : Type.{u3}} [_inst_5 : TopologicalRing.{u2} R _inst_2 (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))] [_inst_6 : TopologicalSpace.{u1} M] [_inst_7 : TopologicalAddGroup.{u1} M _inst_6 (AddCommGroup.toAddGroup.{u1} M _inst_3)] {p : ι -> Prop} {b : ι -> (Set.{u1} M)}, (Filter.HasBasis.{u1, succ u3} M ι (nhds.{u1} M _inst_6 (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3)))))))) p b) -> (forall {i : ι}, (p i) -> (Exists.{succ u2} (Set.{u2} R) (fun (V : Set.{u2} R) => And (Membership.mem.{u2, u2} (Set.{u2} R) (Filter.{u2} R) (instMembershipSetFilter.{u2} R) V (nhds.{u2} R _inst_2 (OfNat.ofNat.{u2} R 0 (Zero.toOfNat0.{u2} R (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))))) (Exists.{succ u3} ι (fun (j : ι) => Exists.{0} (p j) (fun (x._@.Mathlib.Topology.Algebra.FilterBasis._hyg.3702 : p j) => HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) (HSMul.hSMul.{u2, u1, u1} (Set.{u2} R) (Set.{u1} M) (Set.{u1} M) (instHSMul.{u2, u1} (Set.{u2} R) (Set.{u1} M) (Set.smul.{u2, u1} R M (SMulZeroClass.toSMul.{u2, u1} R M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u2, u1} R M (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u2, u1} R M (Semiring.toMonoidWithZero.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (Module.toMulActionWithZero.{u2, u1} R M (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3) _inst_4)))))) V (b j)) (b i))))))) -> (forall (x₀ : R) {i : ι}, (p i) -> (Exists.{succ u3} ι (fun (j : ι) => Exists.{0} (p j) (fun (hj : p j) => HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) (b j) (Set.preimage.{u1, u1} M M (fun (x : M) => HSMul.hSMul.{u2, u1, u1} R M M (instHSMul.{u2, u1} R M (SMulZeroClass.toSMul.{u2, u1} R M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u2, u1} R M (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u2, u1} R M (Semiring.toMonoidWithZero.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (Module.toMulActionWithZero.{u2, u1} R M (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3) _inst_4))))) x₀ x) (b i)))))) -> (forall (m₀ : M) {i : ι}, (p i) -> (Filter.Eventually.{u2} R (fun (x : R) => Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (HSMul.hSMul.{u2, u1, u1} R M M (instHSMul.{u2, u1} R M (SMulZeroClass.toSMul.{u2, u1} R M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u2, u1} R M (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u2, u1} R M (Semiring.toMonoidWithZero.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (Module.toMulActionWithZero.{u2, u1} R M (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3) _inst_4))))) x m₀) (b i)) (nhds.{u2} R _inst_2 (OfNat.ofNat.{u2} R 0 (Zero.toOfNat0.{u2} R (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))))))) -> (ContinuousSMul.{u2, u1} R M (SMulZeroClass.toSMul.{u2, u1} R M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u2, u1} R M (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u2, u1} R M (Semiring.toMonoidWithZero.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (Module.toMulActionWithZero.{u2, u1} R M (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3) _inst_4)))) _inst_2 _inst_6)
 Case conversion may be inaccurate. Consider using '#align has_continuous_smul.of_basis_zero ContinuousSMul.of_basis_zeroₓ'. -/
 /-- A topological add group whith a basis of `𝓝 0` satisfying the axioms of `module_filter_basis`
 is a topological module.
@@ -607,7 +607,7 @@ instance (priority := 100) continuousSMul [TopologicalRing R] :
 lean 3 declaration is
   forall {R : Type.{u1}} {M : Type.{u2}} [_inst_5 : CommRing.{u1} R] [_inst_6 : AddCommGroup.{u2} M] [_inst_7 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)] (BR : RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (BM : AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)), (forall {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.hasMem.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.hasMem.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) => Exists.{succ u2} (Set.{u2} M) (fun (W : Set.{u2} M) => Exists.{0} (Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) W BM) (fun (H : Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) W BM) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) (SMul.smul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7))))) V W) U)))))) -> (forall (x₀ : R) {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u2} (Set.{u2} M) (fun (V : Set.{u2} M) => Exists.{0} (Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) V BM) (fun (H : Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) V BM) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) V (Set.preimage.{u2, u2} M M (fun (x : M) => SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7)))) x₀ x) U))))) -> (forall (m₀ : M) {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.hasMem.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.hasMem.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) => HasSubset.Subset.{u1} (Set.{u1} R) (Set.hasSubset.{u1} R) V (Set.preimage.{u1, u2} R M (fun (x : R) => SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7)))) x m₀) U))))) -> (ModuleFilterBasis.{u1, u2} R M _inst_5 (RingFilterBasis.topology.{u1} R (CommRing.toRing.{u1} R _inst_5) BR) _inst_6 _inst_7)
 but is expected to have type
-  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_5 : CommRing.{u1} R] [_inst_6 : AddCommGroup.{u2} M] [_inst_7 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)] (BR : RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (BM : AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)), (forall {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) (Exists.{succ u2} (Set.{u2} M) (fun (W : Set.{u2} M) => And (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) W BM) (HasSubset.Subset.{u2} (Set.{u2} M) (Set.instHasSubsetSet.{u2} M) (HSMul.hSMul.{u1, u2, u2} (Set.{u1} R) (Set.{u2} M) (Set.{u2} M) (instHSMul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7)))))) V W) U)))))) -> (forall (x₀ : R) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u2} (Set.{u2} M) (fun (V : Set.{u2} M) => And (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) V BM) (HasSubset.Subset.{u2} (Set.{u2} M) (Set.instHasSubsetSet.{u2} M) V (Set.preimage.{u2, u2} M M (fun (x : M) => HSMul.hSMul.{u1, u2, u2} R M M (instHSMul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7))))) x₀ x) U))))) -> (forall (m₀ : M) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) (HasSubset.Subset.{u1} (Set.{u1} R) (Set.instHasSubsetSet.{u1} R) V (Set.preimage.{u1, u2} R M (fun (x : R) => HSMul.hSMul.{u1, u2, u2} R M M (instHSMul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7))))) x m₀) U))))) -> (ModuleFilterBasis.{u1, u2} R M _inst_5 (RingFilterBasis.topology.{u1} R (CommRing.toRing.{u1} R _inst_5) BR) _inst_6 _inst_7)
+  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_5 : CommRing.{u1} R] [_inst_6 : AddCommGroup.{u2} M] [_inst_7 : Module.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)] (BR : RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (BM : AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)), (forall {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) (Exists.{succ u2} (Set.{u2} M) (fun (W : Set.{u2} M) => And (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) W BM) (HasSubset.Subset.{u2} (Set.{u2} M) (Set.instHasSubsetSet.{u2} M) (HSMul.hSMul.{u1, u2, u2} (Set.{u1} R) (Set.{u2} M) (Set.{u2} M) (instHSMul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (Module.toMulActionWithZero.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7)))))) V W) U)))))) -> (forall (x₀ : R) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u2} (Set.{u2} M) (fun (V : Set.{u2} M) => And (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) V BM) (HasSubset.Subset.{u2} (Set.{u2} M) (Set.instHasSubsetSet.{u2} M) V (Set.preimage.{u2, u2} M M (fun (x : M) => HSMul.hSMul.{u1, u2, u2} R M M (instHSMul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (Module.toMulActionWithZero.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7))))) x₀ x) U))))) -> (forall (m₀ : M) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) (HasSubset.Subset.{u1} (Set.{u1} R) (Set.instHasSubsetSet.{u1} R) V (Set.preimage.{u1, u2} R M (fun (x : R) => HSMul.hSMul.{u1, u2, u2} R M M (instHSMul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (Module.toMulActionWithZero.{u1, u2} R M (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7))))) x m₀) U))))) -> (ModuleFilterBasis.{u1, u2} R M _inst_5 (RingFilterBasis.topology.{u1} R (CommRing.toRing.{u1} R _inst_5) BR) _inst_6 _inst_7)
 Case conversion may be inaccurate. Consider using '#align module_filter_basis.of_bases ModuleFilterBasis.ofBasesₓ'. -/
 /-- Build a module filter basis from compatible ring and additive group filter bases. -/
 def ofBases {R M : Type _} [CommRing R] [AddCommGroup M] [Module R M] (BR : RingFilterBasis R)

mathlib commit https://github.com/leanprover-community/mathlib/commit/284fdd2962e67d2932fa3a79ce19fcf92d38e228

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot
 
 ! This file was ported from Lean 3 source module topology.algebra.filter_basis
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
+! leanprover-community/mathlib commit 19cb3751e5e9b3d97adb51023949c50c13b5fdfd
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Topology.Algebra.Module.Basic
 /-!
 # Group and ring filter bases
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 A `group_filter_basis` is a `filter_basis` on a group with some properties relating
 the basis to the group structure. The main theorem is that a `group_filter_basis`
 on a group gives a topology on the group which makes it into a topological group

mathlib commit https://github.com/leanprover-community/mathlib/commit/06a655b5fcfbda03502f9158bbf6c0f1400886f9

@@ -46,6 +46,7 @@ open Topology Filter Pointwise
 
 universe u
 
+#print GroupFilterBasis /-
 /-- A `group_filter_basis` on a group is a `filter_basis` satisfying some additional axioms.
   Example : if `G` is a topological group then the neighbourhoods of the identity are a
   `group_filter_basis`. Conversely given a `group_filter_basis` one can define a topology
@@ -56,7 +57,9 @@ class GroupFilterBasis (G : Type u) [Group G] extends FilterBasis G where
   inv' : ∀ {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x => x⁻¹) ⁻¹' U
   conj' : ∀ x₀, ∀ {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x => x₀ * x * x₀⁻¹) ⁻¹' U
 #align group_filter_basis GroupFilterBasis
+-/
 
+#print AddGroupFilterBasis /-
 /-- A `add_group_filter_basis` on an additive group is a `filter_basis` satisfying some additional
   axioms. Example : if `G` is a topological group then the neighbourhoods of the identity are a
   `add_group_filter_basis`. Conversely given a `add_group_filter_basis` one can define a topology
@@ -67,6 +70,7 @@ class AddGroupFilterBasis (A : Type u) [AddGroup A] extends FilterBasis A where
   neg' : ∀ {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x => -x) ⁻¹' U
   conj' : ∀ x₀, ∀ {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x => x₀ + x + -x₀) ⁻¹' U
 #align add_group_filter_basis AddGroupFilterBasis
+-/
 
 attribute [to_additive] GroupFilterBasis
 
@@ -80,6 +84,12 @@ attribute [to_additive] GroupFilterBasis.conj'
 
 attribute [to_additive] GroupFilterBasis.toFilterBasis
 
+/- warning: group_filter_basis_of_comm -> groupFilterBasisOfComm is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_1 : CommGroup.{u1} G] (sets : Set.{u1} (Set.{u1} G)), (Set.Nonempty.{u1} (Set.{u1} G) sets) -> (forall (x : Set.{u1} G) (y : Set.{u1} G), (Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) x sets) -> (Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) y sets) -> (Exists.{succ u1} (Set.{u1} G) (fun (z : Set.{u1} G) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) z sets) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) z sets) => HasSubset.Subset.{u1} (Set.{u1} G) (Set.hasSubset.{u1} G) z (Inter.inter.{u1} (Set.{u1} G) (Set.hasInter.{u1} G) x y))))) -> (forall (U : Set.{u1} G), (Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) U sets) -> (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1)))))))) U)) -> (forall (U : Set.{u1} G), (Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) U sets) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) V sets) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) V sets) => HasSubset.Subset.{u1} (Set.{u1} G) (Set.hasSubset.{u1} G) (HMul.hMul.{u1, u1, u1} (Set.{u1} G) (Set.{u1} G) (Set.{u1} G) (instHMul.{u1} (Set.{u1} G) (Set.mul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))))) V V) U)))) -> (forall (U : Set.{u1} G), (Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) U sets) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) V sets) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.hasMem.{u1} (Set.{u1} G)) V sets) => HasSubset.Subset.{u1} (Set.{u1} G) (Set.hasSubset.{u1} G) V (Set.preimage.{u1, u1} G G (fun (x : G) => Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))) x) U))))) -> (GroupFilterBasis.{u1} G (CommGroup.toGroup.{u1} G _inst_1))
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_1 : CommGroup.{u1} G] (sets : Set.{u1} (Set.{u1} G)), (Set.Nonempty.{u1} (Set.{u1} G) sets) -> (forall (x : Set.{u1} G) (y : Set.{u1} G), (Membership.mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.instMembershipSet.{u1} (Set.{u1} G)) x sets) -> (Membership.mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.instMembershipSet.{u1} (Set.{u1} G)) y sets) -> (Exists.{succ u1} (Set.{u1} G) (fun (z : Set.{u1} G) => And (Membership.mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.instMembershipSet.{u1} (Set.{u1} G)) z sets) (HasSubset.Subset.{u1} (Set.{u1} G) (Set.instHasSubsetSet.{u1} G) z (Inter.inter.{u1} (Set.{u1} G) (Set.instInterSet.{u1} G) x y))))) -> (forall (U : Set.{u1} G), (Membership.mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.instMembershipSet.{u1} (Set.{u1} G)) U sets) -> (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G (CommGroup.toDivisionCommMonoid.{u1} G _inst_1))))))) U)) -> (forall (U : Set.{u1} G), (Membership.mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.instMembershipSet.{u1} (Set.{u1} G)) U sets) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => And (Membership.mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.instMembershipSet.{u1} (Set.{u1} G)) V sets) (HasSubset.Subset.{u1} (Set.{u1} G) (Set.instHasSubsetSet.{u1} G) (HMul.hMul.{u1, u1, u1} (Set.{u1} G) (Set.{u1} G) (Set.{u1} G) (instHMul.{u1} (Set.{u1} G) (Set.mul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))))) V V) U)))) -> (forall (U : Set.{u1} G), (Membership.mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.instMembershipSet.{u1} (Set.{u1} G)) U sets) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => And (Membership.mem.{u1, u1} (Set.{u1} G) (Set.{u1} (Set.{u1} G)) (Set.instMembershipSet.{u1} (Set.{u1} G)) V sets) (HasSubset.Subset.{u1} (Set.{u1} G) (Set.instHasSubsetSet.{u1} G) V (Set.preimage.{u1, u1} G G (fun (x : G) => Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G (CommGroup.toDivisionCommMonoid.{u1} G _inst_1))))) x) U))))) -> (GroupFilterBasis.{u1} G (CommGroup.toGroup.{u1} G _inst_1))
+Case conversion may be inaccurate. Consider using '#align group_filter_basis_of_comm groupFilterBasisOfCommₓ'. -/
 /-- `group_filter_basis` constructor in the commutative group case. -/
 @[to_additive "`add_group_filter_basis` constructor in the additive commutative group case."]
 def groupFilterBasisOfComm {G : Type _} [CommGroup G] (sets : Set (Set G))
@@ -104,24 +114,48 @@ variable {G : Type u} [Group G] {B : GroupFilterBasis G}
 instance : Membership (Set G) (GroupFilterBasis G) :=
   ⟨fun s f => s ∈ f.sets⟩
 
+/- warning: group_filter_basis.one -> GroupFilterBasis.one is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {B : GroupFilterBasis.{u1} G _inst_1} {U : Set.{u1} G}, (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) U B) -> (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) U)
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {B : GroupFilterBasis.{u1} G _inst_1} {U : Set.{u1} G}, (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) U B) -> (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))))) U)
+Case conversion may be inaccurate. Consider using '#align group_filter_basis.one GroupFilterBasis.oneₓ'. -/
 @[to_additive]
 theorem one {U : Set G} : U ∈ B → (1 : G) ∈ U :=
   GroupFilterBasis.one'
 #align group_filter_basis.one GroupFilterBasis.one
 #align add_group_filter_basis.zero AddGroupFilterBasis.zero
 
+/- warning: group_filter_basis.mul -> GroupFilterBasis.mul is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {B : GroupFilterBasis.{u1} G _inst_1} {U : Set.{u1} G}, (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) => HasSubset.Subset.{u1} (Set.{u1} G) (Set.hasSubset.{u1} G) (HMul.hMul.{u1, u1, u1} (Set.{u1} G) (Set.{u1} G) (Set.{u1} G) (instHMul.{u1} (Set.{u1} G) (Set.mul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) V V) U)))
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {B : GroupFilterBasis.{u1} G _inst_1} {U : Set.{u1} G}, (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => And (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) V B) (HasSubset.Subset.{u1} (Set.{u1} G) (Set.instHasSubsetSet.{u1} G) (HMul.hMul.{u1, u1, u1} (Set.{u1} G) (Set.{u1} G) (Set.{u1} G) (instHMul.{u1} (Set.{u1} G) (Set.mul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) V V) U)))
+Case conversion may be inaccurate. Consider using '#align group_filter_basis.mul GroupFilterBasis.mulₓ'. -/
 @[to_additive]
 theorem mul {U : Set G} : U ∈ B → ∃ V ∈ B, V * V ⊆ U :=
   GroupFilterBasis.mul'
 #align group_filter_basis.mul GroupFilterBasis.mul
 #align add_group_filter_basis.add AddGroupFilterBasis.add
 
+/- warning: group_filter_basis.inv -> GroupFilterBasis.inv is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {B : GroupFilterBasis.{u1} G _inst_1} {U : Set.{u1} G}, (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) => HasSubset.Subset.{u1} (Set.{u1} G) (Set.hasSubset.{u1} G) V (Set.preimage.{u1, u1} G G (fun (x : G) => Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) x) U))))
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {B : GroupFilterBasis.{u1} G _inst_1} {U : Set.{u1} G}, (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => And (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) V B) (HasSubset.Subset.{u1} (Set.{u1} G) (Set.instHasSubsetSet.{u1} G) V (Set.preimage.{u1, u1} G G (fun (x : G) => Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) x) U))))
+Case conversion may be inaccurate. Consider using '#align group_filter_basis.inv GroupFilterBasis.invₓ'. -/
 @[to_additive]
 theorem inv {U : Set G} : U ∈ B → ∃ V ∈ B, V ⊆ (fun x => x⁻¹) ⁻¹' U :=
   GroupFilterBasis.inv'
 #align group_filter_basis.inv GroupFilterBasis.inv
 #align add_group_filter_basis.neg AddGroupFilterBasis.neg
 
+/- warning: group_filter_basis.conj -> GroupFilterBasis.conj is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {B : GroupFilterBasis.{u1} G _inst_1} (x₀ : G) {U : Set.{u1} G}, (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) => HasSubset.Subset.{u1} (Set.{u1} G) (Set.hasSubset.{u1} G) V (Set.preimage.{u1, u1} G G (fun (x : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x₀ x) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) x₀)) U))))
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {B : GroupFilterBasis.{u1} G _inst_1} (x₀ : G) {U : Set.{u1} G}, (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} G) (fun (V : Set.{u1} G) => And (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) V B) (HasSubset.Subset.{u1} (Set.{u1} G) (Set.instHasSubsetSet.{u1} G) V (Set.preimage.{u1, u1} G G (fun (x : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x₀ x) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) x₀)) U))))
+Case conversion may be inaccurate. Consider using '#align group_filter_basis.conj GroupFilterBasis.conjₓ'. -/
 @[to_additive]
 theorem conj : ∀ x₀, ∀ {U}, U ∈ B → ∃ V ∈ B, V ⊆ (fun x => x₀ * x * x₀⁻¹) ⁻¹' U :=
   GroupFilterBasis.conj'
@@ -152,41 +186,64 @@ instance : Inhabited (GroupFilterBasis G) :=
       use {1}
       simp⟩
 
+/- warning: group_filter_basis.prod_subset_self -> GroupFilterBasis.prod_subset_self is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1) {U : Set.{u1} G}, (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) U B) -> (HasSubset.Subset.{u1} (Set.{u1} G) (Set.hasSubset.{u1} G) U (HMul.hMul.{u1, u1, u1} (Set.{u1} G) (Set.{u1} G) (Set.{u1} G) (instHMul.{u1} (Set.{u1} G) (Set.mul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) U U))
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1) {U : Set.{u1} G}, (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) U B) -> (HasSubset.Subset.{u1} (Set.{u1} G) (Set.instHasSubsetSet.{u1} G) U (HMul.hMul.{u1, u1, u1} (Set.{u1} G) (Set.{u1} G) (Set.{u1} G) (instHMul.{u1} (Set.{u1} G) (Set.mul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) U U))
+Case conversion may be inaccurate. Consider using '#align group_filter_basis.prod_subset_self GroupFilterBasis.prod_subset_selfₓ'. -/
 @[to_additive]
 theorem prod_subset_self (B : GroupFilterBasis G) {U : Set G} (h : U ∈ B) : U ⊆ U * U :=
   fun x x_in => ⟨1, x, one h, x_in, one_mul x⟩
 #align group_filter_basis.prod_subset_self GroupFilterBasis.prod_subset_self
 #align add_group_filter_basis.sum_subset_self AddGroupFilterBasis.sum_subset_self
 
+#print GroupFilterBasis.N /-
 /-- The neighborhood function of a `group_filter_basis` -/
 @[to_additive "The neighborhood function of a `add_group_filter_basis`"]
-def n (B : GroupFilterBasis G) : G → Filter G := fun x =>
+def N (B : GroupFilterBasis G) : G → Filter G := fun x =>
   map (fun y => x * y) B.toFilterBasis.filterₓ
-#align group_filter_basis.N GroupFilterBasis.n
-#align add_group_filter_basis.N AddGroupFilterBasis.n
+#align group_filter_basis.N GroupFilterBasis.N
+#align add_group_filter_basis.N AddGroupFilterBasis.N
+-/
 
+/- warning: group_filter_basis.N_one -> GroupFilterBasis.N_one is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1), Eq.{succ u1} (Filter.{u1} G) (GroupFilterBasis.N.{u1} G _inst_1 B (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))))) (FilterBasis.filter.{u1} G (GroupFilterBasis.toFilterBasis.{u1} G _inst_1 B))
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1), Eq.{succ u1} (Filter.{u1} G) (GroupFilterBasis.N.{u1} G _inst_1 B (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1))))))) (FilterBasis.filter.{u1} G (GroupFilterBasis.toFilterBasis.{u1} G _inst_1 B))
+Case conversion may be inaccurate. Consider using '#align group_filter_basis.N_one GroupFilterBasis.N_oneₓ'. -/
 @[simp, to_additive]
-theorem n_one (B : GroupFilterBasis G) : B.n 1 = B.toFilterBasis.filterₓ := by
+theorem N_one (B : GroupFilterBasis G) : B.N 1 = B.toFilterBasis.filterₓ := by
   simp only [N, one_mul, map_id']
-#align group_filter_basis.N_one GroupFilterBasis.n_one
-#align add_group_filter_basis.N_zero AddGroupFilterBasis.n_zero
-
+#align group_filter_basis.N_one GroupFilterBasis.N_one
+#align add_group_filter_basis.N_zero AddGroupFilterBasis.N_zero
+
+/- warning: group_filter_basis.has_basis -> GroupFilterBasis.hasBasis is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1) (x : G), Filter.HasBasis.{u1, succ u1} G (Set.{u1} G) (GroupFilterBasis.N.{u1} G _inst_1 B x) (fun (V : Set.{u1} G) => Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) (fun (V : Set.{u1} G) => Set.image.{u1, u1} G G (fun (y : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x y) V)
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1) (x : G), Filter.HasBasis.{u1, succ u1} G (Set.{u1} G) (GroupFilterBasis.N.{u1} G _inst_1 B x) (fun (V : Set.{u1} G) => Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) V B) (fun (V : Set.{u1} G) => Set.image.{u1, u1} G G (fun (y : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x y) V)
+Case conversion may be inaccurate. Consider using '#align group_filter_basis.has_basis GroupFilterBasis.hasBasisₓ'. -/
 @[to_additive]
 protected theorem hasBasis (B : GroupFilterBasis G) (x : G) :
-    HasBasis (B.n x) (fun V : Set G => V ∈ B) fun V => (fun y => x * y) '' V :=
+    HasBasis (B.N x) (fun V : Set G => V ∈ B) fun V => (fun y => x * y) '' V :=
   HasBasis.map (fun y => x * y) toFilterBasis.HasBasis
 #align group_filter_basis.has_basis GroupFilterBasis.hasBasis
 #align add_group_filter_basis.has_basis AddGroupFilterBasis.hasBasis
 
+#print GroupFilterBasis.topology /-
 /-- The topological space structure coming from a group filter basis. -/
 @[to_additive "The topological space structure coming from an additive group filter basis."]
 def topology (B : GroupFilterBasis G) : TopologicalSpace G :=
-  TopologicalSpace.mkOfNhds B.n
+  TopologicalSpace.mkOfNhds B.N
 #align group_filter_basis.topology GroupFilterBasis.topology
 #align add_group_filter_basis.topology AddGroupFilterBasis.topology
+-/
 
+#print GroupFilterBasis.nhds_eq /-
 @[to_additive]
-theorem nhds_eq (B : GroupFilterBasis G) {x₀ : G} : @nhds G B.topology x₀ = B.n x₀ :=
+theorem nhds_eq (B : GroupFilterBasis G) {x₀ : G} : @nhds G B.topology x₀ = B.N x₀ :=
   by
   rw [TopologicalSpace.nhds_mkOfNhds]
   · intro x U U_in
@@ -210,7 +267,14 @@ theorem nhds_eq (B : GroupFilterBasis G) {x₀ : G} : @nhds G B.topology x₀ =
       exact ⟨t * w, hW (mul_mem_mul tW wW), by simp [mul_assoc]⟩
 #align group_filter_basis.nhds_eq GroupFilterBasis.nhds_eq
 #align add_group_filter_basis.nhds_eq AddGroupFilterBasis.nhds_eq
+-/
 
+/- warning: group_filter_basis.nhds_one_eq -> GroupFilterBasis.nhds_one_eq is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1), Eq.{succ u1} (Filter.{u1} G) (nhds.{u1} G (GroupFilterBasis.topology.{u1} G _inst_1 B) (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))))) (FilterBasis.filter.{u1} G (GroupFilterBasis.toFilterBasis.{u1} G _inst_1 B))
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1), Eq.{succ u1} (Filter.{u1} G) (nhds.{u1} G (GroupFilterBasis.topology.{u1} G _inst_1 B) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1))))))) (FilterBasis.filter.{u1} G (GroupFilterBasis.toFilterBasis.{u1} G _inst_1 B))
+Case conversion may be inaccurate. Consider using '#align group_filter_basis.nhds_one_eq GroupFilterBasis.nhds_one_eqₓ'. -/
 @[to_additive]
 theorem nhds_one_eq (B : GroupFilterBasis G) :
     @nhds G B.topology (1 : G) = B.toFilterBasis.filterₓ :=
@@ -221,6 +285,12 @@ theorem nhds_one_eq (B : GroupFilterBasis G) :
 #align group_filter_basis.nhds_one_eq GroupFilterBasis.nhds_one_eq
 #align add_group_filter_basis.nhds_zero_eq AddGroupFilterBasis.nhds_zero_eq
 
+/- warning: group_filter_basis.nhds_has_basis -> GroupFilterBasis.nhds_hasBasis is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1) (x₀ : G), Filter.HasBasis.{u1, succ u1} G (Set.{u1} G) (nhds.{u1} G (GroupFilterBasis.topology.{u1} G _inst_1 B) x₀) (fun (V : Set.{u1} G) => Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) (fun (V : Set.{u1} G) => Set.image.{u1, u1} G G (fun (y : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x₀ y) V)
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1) (x₀ : G), Filter.HasBasis.{u1, succ u1} G (Set.{u1} G) (nhds.{u1} G (GroupFilterBasis.topology.{u1} G _inst_1 B) x₀) (fun (V : Set.{u1} G) => Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) V B) (fun (V : Set.{u1} G) => Set.image.{u1, u1} G G (fun (y : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x₀ y) V)
+Case conversion may be inaccurate. Consider using '#align group_filter_basis.nhds_has_basis GroupFilterBasis.nhds_hasBasisₓ'. -/
 @[to_additive]
 theorem nhds_hasBasis (B : GroupFilterBasis G) (x₀ : G) :
     HasBasis (@nhds G B.topology x₀) (fun V : Set G => V ∈ B) fun V => (fun y => x₀ * y) '' V :=
@@ -230,6 +300,12 @@ theorem nhds_hasBasis (B : GroupFilterBasis G) (x₀ : G) :
 #align group_filter_basis.nhds_has_basis GroupFilterBasis.nhds_hasBasis
 #align add_group_filter_basis.nhds_has_basis AddGroupFilterBasis.nhds_hasBasis
 
+/- warning: group_filter_basis.nhds_one_has_basis -> GroupFilterBasis.nhds_one_hasBasis is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1), Filter.HasBasis.{u1, succ u1} G (Set.{u1} G) (nhds.{u1} G (GroupFilterBasis.topology.{u1} G _inst_1 B) (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))))) (fun (V : Set.{u1} G) => Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) V B) (id.{succ u1} (Set.{u1} G))
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1), Filter.HasBasis.{u1, succ u1} G (Set.{u1} G) (nhds.{u1} G (GroupFilterBasis.topology.{u1} G _inst_1 B) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1))))))) (fun (V : Set.{u1} G) => Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) V B) (id.{succ u1} (Set.{u1} G))
+Case conversion may be inaccurate. Consider using '#align group_filter_basis.nhds_one_has_basis GroupFilterBasis.nhds_one_hasBasisₓ'. -/
 @[to_additive]
 theorem nhds_one_hasBasis (B : GroupFilterBasis G) :
     HasBasis (@nhds G B.topology 1) (fun V : Set G => V ∈ B) id :=
@@ -239,6 +315,12 @@ theorem nhds_one_hasBasis (B : GroupFilterBasis G) :
 #align group_filter_basis.nhds_one_has_basis GroupFilterBasis.nhds_one_hasBasis
 #align add_group_filter_basis.nhds_zero_has_basis AddGroupFilterBasis.nhds_zero_hasBasis
 
+/- warning: group_filter_basis.mem_nhds_one -> GroupFilterBasis.mem_nhds_one is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1) {U : Set.{u1} G}, (Membership.Mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.hasMem.{u1} G _inst_1) U B) -> (Membership.Mem.{u1, u1} (Set.{u1} G) (Filter.{u1} G) (Filter.hasMem.{u1} G) U (nhds.{u1} G (GroupFilterBasis.topology.{u1} G _inst_1 B) (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))))))
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (B : GroupFilterBasis.{u1} G _inst_1) {U : Set.{u1} G}, (Membership.mem.{u1, u1} (Set.{u1} G) (GroupFilterBasis.{u1} G _inst_1) (GroupFilterBasis.instMembershipSetGroupFilterBasis.{u1} G _inst_1) U B) -> (Membership.mem.{u1, u1} (Set.{u1} G) (Filter.{u1} G) (instMembershipSetFilter.{u1} G) U (nhds.{u1} G (GroupFilterBasis.topology.{u1} G _inst_1 B) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align group_filter_basis.mem_nhds_one GroupFilterBasis.mem_nhds_oneₓ'. -/
 @[to_additive]
 theorem mem_nhds_one (B : GroupFilterBasis G) {U : Set G} (hU : U ∈ B) : U ∈ @nhds G B.topology 1 :=
   by
@@ -247,12 +329,13 @@ theorem mem_nhds_one (B : GroupFilterBasis G) {U : Set G} (hU : U ∈ B) : U ∈
 #align group_filter_basis.mem_nhds_one GroupFilterBasis.mem_nhds_one
 #align add_group_filter_basis.mem_nhds_zero AddGroupFilterBasis.mem_nhds_zero
 
+#print GroupFilterBasis.isTopologicalGroup /-
 -- See note [lower instance priority]
 /-- If a group is endowed with a topological structure coming from a group filter basis then it's a
 topological group. -/
 @[to_additive
       "If a group is endowed with a topological structure coming from a group filter basis\nthen it's a topological group."]
-instance (priority := 100) is_topologicalGroup (B : GroupFilterBasis G) :
+instance (priority := 100) isTopologicalGroup (B : GroupFilterBasis G) :
     @TopologicalGroup G B.topology _ := by
   letI := B.topology
   have basis := B.nhds_one_has_basis
@@ -275,11 +358,13 @@ instance (priority := 100) is_topologicalGroup (B : GroupFilterBasis G) :
     rw [basis.tendsto_iff Basis]
     intro U U_in
     exact conj x₀ U_in
-#align group_filter_basis.is_topological_group GroupFilterBasis.is_topologicalGroup
-#align add_group_filter_basis.is_topological_add_group AddGroupFilterBasis.is_topological_add_group
+#align group_filter_basis.is_topological_group GroupFilterBasis.isTopologicalGroup
+#align add_group_filter_basis.is_topological_add_group AddGroupFilterBasis.isTopologicalAddGroup
+-/
 
 end GroupFilterBasis
 
+#print RingFilterBasis /-
 /-- A `ring_filter_basis` on a ring is a `filter_basis` satisfying some additional axioms.
   Example : if `R` is a topological ring then the neighbourhoods of the identity are a
   `ring_filter_basis`. Conversely given a `ring_filter_basis` on a ring `R`, one can define a
@@ -289,6 +374,7 @@ class RingFilterBasis (R : Type u) [Ring R] extends AddGroupFilterBasis R where
   mul_left' : ∀ (x₀ : R) {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x => x₀ * x) ⁻¹' U
   mul_right' : ∀ (x₀ : R) {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x => x * x₀) ⁻¹' U
 #align ring_filter_basis RingFilterBasis
+-/
 
 namespace RingFilterBasis
 
@@ -297,27 +383,48 @@ variable {R : Type u} [Ring R] (B : RingFilterBasis R)
 instance : Membership (Set R) (RingFilterBasis R) :=
   ⟨fun s B => s ∈ B.sets⟩
 
+/- warning: ring_filter_basis.mul -> RingFilterBasis.mul is a dubious translation:
+lean 3 declaration is
+  forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] (B : RingFilterBasis.{u1} R _inst_1) {U : Set.{u1} R}, (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) V B) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) V B) => HasSubset.Subset.{u1} (Set.{u1} R) (Set.hasSubset.{u1} R) (HMul.hMul.{u1, u1, u1} (Set.{u1} R) (Set.{u1} R) (Set.{u1} R) (instHMul.{u1} (Set.{u1} R) (Set.mul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_1)))) V V) U)))
+but is expected to have type
+  forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] (B : RingFilterBasis.{u1} R _inst_1) {U : Set.{u1} R}, (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R _inst_1) V B) (HasSubset.Subset.{u1} (Set.{u1} R) (Set.instHasSubsetSet.{u1} R) (HMul.hMul.{u1, u1, u1} (Set.{u1} R) (Set.{u1} R) (Set.{u1} R) (instHMul.{u1} (Set.{u1} R) (Set.mul.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) V V) U)))
+Case conversion may be inaccurate. Consider using '#align ring_filter_basis.mul RingFilterBasis.mulₓ'. -/
 theorem mul {U : Set R} (hU : U ∈ B) : ∃ V ∈ B, V * V ⊆ U :=
   mul' hU
 #align ring_filter_basis.mul RingFilterBasis.mul
 
+/- warning: ring_filter_basis.mul_left -> RingFilterBasis.mul_left is a dubious translation:
+lean 3 declaration is
+  forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] (B : RingFilterBasis.{u1} R _inst_1) (x₀ : R) {U : Set.{u1} R}, (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) V B) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) V B) => HasSubset.Subset.{u1} (Set.{u1} R) (Set.hasSubset.{u1} R) V (Set.preimage.{u1, u1} R R (fun (x : R) => HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_1))) x₀ x) U))))
+but is expected to have type
+  forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] (B : RingFilterBasis.{u1} R _inst_1) (x₀ : R) {U : Set.{u1} R}, (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R _inst_1) V B) (HasSubset.Subset.{u1} (Set.{u1} R) (Set.instHasSubsetSet.{u1} R) V (Set.preimage.{u1, u1} R R (fun (x : R) => HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))) x₀ x) U))))
+Case conversion may be inaccurate. Consider using '#align ring_filter_basis.mul_left RingFilterBasis.mul_leftₓ'. -/
 theorem mul_left (x₀ : R) {U : Set R} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x => x₀ * x) ⁻¹' U :=
   mul_left' x₀ hU
 #align ring_filter_basis.mul_left RingFilterBasis.mul_left
 
+/- warning: ring_filter_basis.mul_right -> RingFilterBasis.mul_right is a dubious translation:
+lean 3 declaration is
+  forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] (B : RingFilterBasis.{u1} R _inst_1) (x₀ : R) {U : Set.{u1} R}, (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) V B) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.hasMem.{u1} R _inst_1) V B) => HasSubset.Subset.{u1} (Set.{u1} R) (Set.hasSubset.{u1} R) V (Set.preimage.{u1, u1} R R (fun (x : R) => HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_1))) x x₀) U))))
+but is expected to have type
+  forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] (B : RingFilterBasis.{u1} R _inst_1) (x₀ : R) {U : Set.{u1} R}, (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R _inst_1) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R _inst_1) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R _inst_1) V B) (HasSubset.Subset.{u1} (Set.{u1} R) (Set.instHasSubsetSet.{u1} R) V (Set.preimage.{u1, u1} R R (fun (x : R) => HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))) x x₀) U))))
+Case conversion may be inaccurate. Consider using '#align ring_filter_basis.mul_right RingFilterBasis.mul_rightₓ'. -/
 theorem mul_right (x₀ : R) {U : Set R} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x => x * x₀) ⁻¹' U :=
   mul_right' x₀ hU
 #align ring_filter_basis.mul_right RingFilterBasis.mul_right
 
+#print RingFilterBasis.topology /-
 /-- The topology associated to a ring filter basis.
 It has the given basis as a basis of neighborhoods of zero. -/
 def topology : TopologicalSpace R :=
   B.toAddGroupFilterBasis.topology
 #align ring_filter_basis.topology RingFilterBasis.topology
+-/
 
+#print RingFilterBasis.isTopologicalRing /-
 /-- If a ring is endowed with a topological structure coming from
 a ring filter basis then it's a topological ring. -/
-instance (priority := 100) is_topologicalRing {R : Type u} [Ring R] (B : RingFilterBasis R) :
+instance (priority := 100) isTopologicalRing {R : Type u} [Ring R] (B : RingFilterBasis R) :
     @TopologicalRing R B.topology _ :=
   by
   let B' := B.to_add_group_filter_basis
@@ -341,10 +448,12 @@ instance (priority := 100) is_topologicalRing {R : Type u} [Ring R] (B : RingFil
     rw [basis.tendsto_iff Basis]
     intro U
     simpa using B.mul_right x₀
-#align ring_filter_basis.is_topological_ring RingFilterBasis.is_topologicalRing
+#align ring_filter_basis.is_topological_ring RingFilterBasis.isTopologicalRing
+-/
 
 end RingFilterBasis
 
+#print ModuleFilterBasis /-
 /-- A `module_filter_basis` on a module is a `filter_basis` satisfying some additional axioms.
   Example : if `M` is a topological module then the neighbourhoods of zero are a
   `module_filter_basis`. Conversely given a `module_filter_basis` one can define a topology
@@ -355,24 +464,45 @@ structure ModuleFilterBasis (R M : Type _) [CommRing R] [TopologicalSpace R] [Ad
   smul_left' : ∀ (x₀ : R) {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x => x₀ • x) ⁻¹' U
   smul_right' : ∀ (m₀ : M) {U}, U ∈ sets → ∀ᶠ x in 𝓝 (0 : R), x • m₀ ∈ U
 #align module_filter_basis ModuleFilterBasis
+-/
 
 namespace ModuleFilterBasis
 
 variable {R M : Type _} [CommRing R] [TopologicalSpace R] [AddCommGroup M] [Module R M]
   (B : ModuleFilterBasis R M)
 
+#print ModuleFilterBasis.GroupFilterBasis.hasMem /-
 instance GroupFilterBasis.hasMem : Membership (Set M) (ModuleFilterBasis R M) :=
   ⟨fun s B => s ∈ B.sets⟩
 #align module_filter_basis.group_filter_basis.has_mem ModuleFilterBasis.GroupFilterBasis.hasMem
+-/
 
+/- warning: module_filter_basis.smul -> ModuleFilterBasis.smul is a dubious translation:
+lean 3 declaration is
+  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (Filter.{u1} R) (Filter.hasMem.{u1} R) V (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1))))))))))) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (Filter.{u1} R) (Filter.hasMem.{u1} R) V (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1))))))))))) => Exists.{succ u2} (Set.{u2} M) (fun (W : Set.{u2} M) => Exists.{0} (Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) W B) (fun (H : Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) W B) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) (SMul.smul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4))))) V W) U)))))
+but is expected to have type
+  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (Filter.{u1} R) (instMembershipSetFilter.{u1} R) V (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))))) (Exists.{succ u2} (Set.{u2} M) (fun (W : Set.{u2} M) => And (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) W B) (HasSubset.Subset.{u2} (Set.{u2} M) (Set.instHasSubsetSet.{u2} M) (HSMul.hSMul.{u1, u2, u2} (Set.{u1} R) (Set.{u2} M) (Set.{u2} M) (instHSMul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))))) V W) U)))))
+Case conversion may be inaccurate. Consider using '#align module_filter_basis.smul ModuleFilterBasis.smulₓ'. -/
 theorem smul {U : Set M} (hU : U ∈ B) : ∃ V ∈ 𝓝 (0 : R), ∃ W ∈ B, V • W ⊆ U :=
   B.smul' hU
 #align module_filter_basis.smul ModuleFilterBasis.smul
 
+/- warning: module_filter_basis.smul_left -> ModuleFilterBasis.smul_left is a dubious translation:
+lean 3 declaration is
+  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (x₀ : R) {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Exists.{succ u2} (Set.{u2} M) (fun (V : Set.{u2} M) => Exists.{0} (Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) V B) (fun (H : Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) V B) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) V (Set.preimage.{u2, u2} M M (fun (x : M) => SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))) x₀ x) U))))
+but is expected to have type
+  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (x₀ : R) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Exists.{succ u2} (Set.{u2} M) (fun (V : Set.{u2} M) => And (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) V B) (HasSubset.Subset.{u2} (Set.{u2} M) (Set.instHasSubsetSet.{u2} M) V (Set.preimage.{u2, u2} M M (fun (x : M) => HSMul.hSMul.{u1, u2, u2} R M M (instHSMul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4))))) x₀ x) U))))
+Case conversion may be inaccurate. Consider using '#align module_filter_basis.smul_left ModuleFilterBasis.smul_leftₓ'. -/
 theorem smul_left (x₀ : R) {U : Set M} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x => x₀ • x) ⁻¹' U :=
   B.smul_left' x₀ hU
 #align module_filter_basis.smul_left ModuleFilterBasis.smul_left
 
+/- warning: module_filter_basis.smul_right -> ModuleFilterBasis.smul_right is a dubious translation:
+lean 3 declaration is
+  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (m₀ : M) {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Filter.Eventually.{u1} R (fun (x : R) => Membership.Mem.{u2, u2} M (Set.{u2} M) (Set.hasMem.{u2} M) (SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))) x m₀) U) (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1)))))))))))
+but is expected to have type
+  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] (B : ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (m₀ : M) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (ModuleFilterBasis.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) (ModuleFilterBasis.GroupFilterBasis.hasMem.{u1, u2} R M _inst_1 _inst_2 _inst_3 _inst_4) U B) -> (Filter.Eventually.{u1} R (fun (x : R) => Membership.mem.{u2, u2} M (Set.{u2} M) (Set.instMembershipSet.{u2} M) (HSMul.hSMul.{u1, u2, u2} R M M (instHSMul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_3))))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4))))) x m₀) U) (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))))
+Case conversion may be inaccurate. Consider using '#align module_filter_basis.smul_right ModuleFilterBasis.smul_rightₓ'. -/
 theorem smul_right (m₀ : M) {U : Set M} (hU : U ∈ B) : ∀ᶠ x in 𝓝 (0 : R), x • m₀ ∈ U :=
   B.smul_right' m₀ hU
 #align module_filter_basis.smul_right ModuleFilterBasis.smul_right
@@ -399,12 +529,15 @@ instance [DiscreteTopology R] : Inhabited (ModuleFilterBasis R M) :=
         rw [Set.mem_zero] at h
         simp [h, nhds_discrete] }⟩
 
+#print ModuleFilterBasis.topology /-
 /-- The topology associated to a module filter basis on a module over a topological ring.
 It has the given basis as a basis of neighborhoods of zero. -/
 def topology : TopologicalSpace M :=
   B.toAddGroupFilterBasis.topology
 #align module_filter_basis.topology ModuleFilterBasis.topology
+-/
 
+#print ModuleFilterBasis.topology' /-
 /-- The topology associated to a module filter basis on a module over a topological ring.
 It has the given basis as a basis of neighborhoods of zero. This version gets the ring
 topology by unification instead of type class inference. -/
@@ -412,7 +545,14 @@ def topology' {R M : Type _} [CommRing R] {tR : TopologicalSpace R} [AddCommGrou
     (B : ModuleFilterBasis R M) : TopologicalSpace M :=
   B.toAddGroupFilterBasis.topology
 #align module_filter_basis.topology' ModuleFilterBasis.topology'
+-/
 
+/- warning: has_continuous_smul.of_basis_zero -> ContinuousSMul.of_basis_zero is a dubious translation:
+lean 3 declaration is
+  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_1 : CommRing.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : AddCommGroup.{u2} M] [_inst_4 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)] {ι : Type.{u3}} [_inst_5 : TopologicalRing.{u1} R _inst_2 (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1)))] [_inst_6 : TopologicalSpace.{u2} M] [_inst_7 : TopologicalAddGroup.{u2} M _inst_6 (AddCommGroup.toAddGroup.{u2} M _inst_3)] {p : ι -> Prop} {b : ι -> (Set.{u2} M)}, (Filter.HasBasis.{u2, succ u3} M ι (nhds.{u2} M _inst_6 (OfNat.ofNat.{u2} M 0 (OfNat.mk.{u2} M 0 (Zero.zero.{u2} M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_3))))))))) p b) -> (forall {i : ι}, (p i) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (Filter.{u1} R) (Filter.hasMem.{u1} R) V (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1))))))))))) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (Filter.{u1} R) (Filter.hasMem.{u1} R) V (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1))))))))))) => Exists.{succ u3} ι (fun (j : ι) => Exists.{0} (p j) (fun (hj : p j) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) (SMul.smul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4))))) V (b j)) (b i))))))) -> (forall (x₀ : R) {i : ι}, (p i) -> (Exists.{succ u3} ι (fun (j : ι) => Exists.{0} (p j) (fun (hj : p j) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) (b j) (Set.preimage.{u2, u2} M M (fun (x : M) => SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))) x₀ x) (b i)))))) -> (forall (m₀ : M) {i : ι}, (p i) -> (Filter.Eventually.{u1} R (fun (x : R) => Membership.Mem.{u2, u2} M (Set.{u2} M) (Set.hasMem.{u2} M) (SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))) x m₀) (b i)) (nhds.{u1} R _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R _inst_1)))))))))))) -> (ContinuousSMul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_3)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_3) _inst_4)))) _inst_2 _inst_6)
+but is expected to have type
+  forall {R : Type.{u2}} {M : Type.{u1}} [_inst_1 : CommRing.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : AddCommGroup.{u1} M] [_inst_4 : Module.{u2, u1} R M (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3)] {ι : Type.{u3}} [_inst_5 : TopologicalRing.{u2} R _inst_2 (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))] [_inst_6 : TopologicalSpace.{u1} M] [_inst_7 : TopologicalAddGroup.{u1} M _inst_6 (AddCommGroup.toAddGroup.{u1} M _inst_3)] {p : ι -> Prop} {b : ι -> (Set.{u1} M)}, (Filter.HasBasis.{u1, succ u3} M ι (nhds.{u1} M _inst_6 (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3)))))))) p b) -> (forall {i : ι}, (p i) -> (Exists.{succ u2} (Set.{u2} R) (fun (V : Set.{u2} R) => And (Membership.mem.{u2, u2} (Set.{u2} R) (Filter.{u2} R) (instMembershipSetFilter.{u2} R) V (nhds.{u2} R _inst_2 (OfNat.ofNat.{u2} R 0 (Zero.toOfNat0.{u2} R (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))))) (Exists.{succ u3} ι (fun (j : ι) => Exists.{0} (p j) (fun (x._@.Mathlib.Topology.Algebra.FilterBasis._hyg.3702 : p j) => HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) (HSMul.hSMul.{u2, u1, u1} (Set.{u2} R) (Set.{u1} M) (Set.{u1} M) (instHSMul.{u2, u1} (Set.{u2} R) (Set.{u1} M) (Set.smul.{u2, u1} R M (SMulZeroClass.toSMul.{u2, u1} R M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u2, u1} R M (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u2, u1} R M (Semiring.toMonoidWithZero.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (Module.toMulActionWithZero.{u2, u1} R M (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3) _inst_4)))))) V (b j)) (b i))))))) -> (forall (x₀ : R) {i : ι}, (p i) -> (Exists.{succ u3} ι (fun (j : ι) => Exists.{0} (p j) (fun (hj : p j) => HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) (b j) (Set.preimage.{u1, u1} M M (fun (x : M) => HSMul.hSMul.{u2, u1, u1} R M M (instHSMul.{u2, u1} R M (SMulZeroClass.toSMul.{u2, u1} R M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u2, u1} R M (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u2, u1} R M (Semiring.toMonoidWithZero.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (Module.toMulActionWithZero.{u2, u1} R M (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3) _inst_4))))) x₀ x) (b i)))))) -> (forall (m₀ : M) {i : ι}, (p i) -> (Filter.Eventually.{u2} R (fun (x : R) => Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (HSMul.hSMul.{u2, u1, u1} R M M (instHSMul.{u2, u1} R M (SMulZeroClass.toSMul.{u2, u1} R M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u2, u1} R M (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u2, u1} R M (Semiring.toMonoidWithZero.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (Module.toMulActionWithZero.{u2, u1} R M (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3) _inst_4))))) x m₀) (b i)) (nhds.{u2} R _inst_2 (OfNat.ofNat.{u2} R 0 (Zero.toOfNat0.{u2} R (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))))))) -> (ContinuousSMul.{u2, u1} R M (SMulZeroClass.toSMul.{u2, u1} R M (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (SMulWithZero.toSMulZeroClass.{u2, u1} R M (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (MulActionWithZero.toSMulWithZero.{u2, u1} R M (Semiring.toMonoidWithZero.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1))) (NegZeroClass.toZero.{u1} M (SubNegZeroMonoid.toNegZeroClass.{u1} M (SubtractionMonoid.toSubNegZeroMonoid.{u1} M (SubtractionCommMonoid.toSubtractionMonoid.{u1} M (AddCommGroup.toDivisionAddCommMonoid.{u1} M _inst_3))))) (Module.toMulActionWithZero.{u2, u1} R M (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R _inst_1)) (AddCommGroup.toAddCommMonoid.{u1} M _inst_3) _inst_4)))) _inst_2 _inst_6)
+Case conversion may be inaccurate. Consider using '#align has_continuous_smul.of_basis_zero ContinuousSMul.of_basis_zeroₓ'. -/
 /-- A topological add group whith a basis of `𝓝 0` satisfying the axioms of `module_filter_basis`
 is a topological module.
 
@@ -446,6 +586,7 @@ theorem ContinuousSMul.of_basis_zero {ι : Type _} [TopologicalRing R] [Topologi
     exact mem_of_superset (h.mem_of_mem hj) hji
 #align has_continuous_smul.of_basis_zero ContinuousSMul.of_basis_zero
 
+#print ModuleFilterBasis.continuousSMul /-
 /-- If a module is endowed with a topological structure coming from
 a module filter basis then it's a topological module. -/
 instance (priority := 100) continuousSMul [TopologicalRing R] :
@@ -457,7 +598,14 @@ instance (priority := 100) continuousSMul [TopologicalRing R] :
   exact
     ContinuousSMul.of_basis_zero B'.nhds_zero_has_basis (fun _ => B.smul) B.smul_left B.smul_right
 #align module_filter_basis.has_continuous_smul ModuleFilterBasis.continuousSMul
+-/
 
+/- warning: module_filter_basis.of_bases -> ModuleFilterBasis.ofBases is a dubious translation:
+lean 3 declaration is
+  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_5 : CommRing.{u1} R] [_inst_6 : AddCommGroup.{u2} M] [_inst_7 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)] (BR : RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (BM : AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)), (forall {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.hasMem.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.hasMem.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) => Exists.{succ u2} (Set.{u2} M) (fun (W : Set.{u2} M) => Exists.{0} (Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) W BM) (fun (H : Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) W BM) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) (SMul.smul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7))))) V W) U)))))) -> (forall (x₀ : R) {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u2} (Set.{u2} M) (fun (V : Set.{u2} M) => Exists.{0} (Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) V BM) (fun (H : Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) V BM) => HasSubset.Subset.{u2} (Set.{u2} M) (Set.hasSubset.{u2} M) V (Set.preimage.{u2, u2} M M (fun (x : M) => SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7)))) x₀ x) U))))) -> (forall (m₀ : M) {U : Set.{u2} M}, (Membership.Mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.hasMem.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.hasMem.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.hasMem.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) => HasSubset.Subset.{u1} (Set.{u1} R) (Set.hasSubset.{u1} R) V (Set.preimage.{u1, u2} R M (fun (x : R) => SMul.smul.{u1, u2} R M (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (SMulWithZero.toSmulZeroClass.{u1, u2} R M (MulZeroClass.toHasZero.{u1} R (MulZeroOneClass.toMulZeroClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)))))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5))) (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7)))) x m₀) U))))) -> (ModuleFilterBasis.{u1, u2} R M _inst_5 (RingFilterBasis.topology.{u1} R (CommRing.toRing.{u1} R _inst_5) BR) _inst_6 _inst_7)
+but is expected to have type
+  forall {R : Type.{u1}} {M : Type.{u2}} [_inst_5 : CommRing.{u1} R] [_inst_6 : AddCommGroup.{u2} M] [_inst_7 : Module.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6)] (BR : RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (BM : AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)), (forall {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) (Exists.{succ u2} (Set.{u2} M) (fun (W : Set.{u2} M) => And (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) W BM) (HasSubset.Subset.{u2} (Set.{u2} M) (Set.instHasSubsetSet.{u2} M) (HSMul.hSMul.{u1, u2, u2} (Set.{u1} R) (Set.{u2} M) (Set.{u2} M) (instHSMul.{u1, u2} (Set.{u1} R) (Set.{u2} M) (Set.smul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7)))))) V W) U)))))) -> (forall (x₀ : R) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u2} (Set.{u2} M) (fun (V : Set.{u2} M) => And (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) V BM) (HasSubset.Subset.{u2} (Set.{u2} M) (Set.instHasSubsetSet.{u2} M) V (Set.preimage.{u2, u2} M M (fun (x : M) => HSMul.hSMul.{u1, u2, u2} R M M (instHSMul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7))))) x₀ x) U))))) -> (forall (m₀ : M) {U : Set.{u2} M}, (Membership.mem.{u2, u2} (Set.{u2} M) (AddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) (AddGroupFilterBasis.instMembershipSetAddGroupFilterBasis.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_6)) U BM) -> (Exists.{succ u1} (Set.{u1} R) (fun (V : Set.{u1} R) => And (Membership.mem.{u1, u1} (Set.{u1} R) (RingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) (RingFilterBasis.instMembershipSetRingFilterBasis.{u1} R (CommRing.toRing.{u1} R _inst_5)) V BR) (HasSubset.Subset.{u1} (Set.{u1} R) (Set.instHasSubsetSet.{u1} R) V (Set.preimage.{u1, u2} R M (fun (x : R) => HSMul.hSMul.{u1, u2, u2} R M M (instHSMul.{u1, u2} R M (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (SMulWithZero.toSMulZeroClass.{u1, u2} R M (CommMonoidWithZero.toZero.{u1} R (CommSemiring.toCommMonoidWithZero.{u1} R (CommRing.toCommSemiring.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (MulActionWithZero.toSMulWithZero.{u1, u2} R M (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5))) (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_6))))) (Module.toMulActionWithZero.{u1, u2} R M (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_5)) (AddCommGroup.toAddCommMonoid.{u2} M _inst_6) _inst_7))))) x m₀) U))))) -> (ModuleFilterBasis.{u1, u2} R M _inst_5 (RingFilterBasis.topology.{u1} R (CommRing.toRing.{u1} R _inst_5) BR) _inst_6 _inst_7)
+Case conversion may be inaccurate. Consider using '#align module_filter_basis.of_bases ModuleFilterBasis.ofBasesₓ'. -/
 /-- Build a module filter basis from compatible ring and additive group filter bases. -/
 def ofBases {R M : Type _} [CommRing R] [AddCommGroup M] [Module R M] (BR : RingFilterBasis R)
     (BM : AddGroupFilterBasis M) (smul : ∀ {U}, U ∈ BM → ∃ V ∈ BR, ∃ W ∈ BM, V • W ⊆ U)

mathlib commit https://github.com/leanprover-community/mathlib/commit/21e3562c5e12d846c7def5eff8cdbc520d7d4936

@@ -325,7 +325,7 @@ instance (priority := 100) is_topologicalRing {R : Type u} [Ring R] (B : RingFil
   have basis := B'.nhds_zero_has_basis
   have basis' := Basis.prod Basis
   haveI := B'.is_topological_add_group
-  apply TopologicalRing.of_add_group_of_nhds_zero
+  apply TopologicalRing.of_addGroup_of_nhds_zero
   · rw [basis'.tendsto_iff Basis]
     suffices ∀ U ∈ B', ∃ V W, (V ∈ B' ∧ W ∈ B') ∧ ∀ a b, a ∈ V → b ∈ W → a * b ∈ U by simpa
     intro U U_in

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

@@ -256,23 +256,23 @@ instance (priority := 100) is_topologicalGroup (B : GroupFilterBasis G) :
     @TopologicalGroup G B.topology _ := by
   letI := B.topology
   have basis := B.nhds_one_has_basis
-  have basis' := basis.prod basis
+  have basis' := Basis.prod Basis
   refine' TopologicalGroup.of_nhds_one _ _ _ _
-  · rw [basis'.tendsto_iff basis]
+  · rw [basis'.tendsto_iff Basis]
     suffices ∀ U ∈ B, ∃ V W, (V ∈ B ∧ W ∈ B) ∧ ∀ a b, a ∈ V → b ∈ W → a * b ∈ U by simpa
     intro U U_in
     rcases mul U_in with ⟨V, V_in, hV⟩
     use V, V, V_in, V_in
     intro a b a_in b_in
     exact hV ⟨a, b, a_in, b_in, rfl⟩
-  · rw [basis.tendsto_iff basis]
+  · rw [basis.tendsto_iff Basis]
     intro U U_in
     simpa using inv U_in
   · intro x₀
     rw [nhds_eq, nhds_one_eq]
     rfl
   · intro x₀
-    rw [basis.tendsto_iff basis]
+    rw [basis.tendsto_iff Basis]
     intro U U_in
     exact conj x₀ U_in
 #align group_filter_basis.is_topological_group GroupFilterBasis.is_topologicalGroup
@@ -323,10 +323,10 @@ instance (priority := 100) is_topologicalRing {R : Type u} [Ring R] (B : RingFil
   let B' := B.to_add_group_filter_basis
   letI := B'.topology
   have basis := B'.nhds_zero_has_basis
-  have basis' := basis.prod basis
+  have basis' := Basis.prod Basis
   haveI := B'.is_topological_add_group
   apply TopologicalRing.of_add_group_of_nhds_zero
-  · rw [basis'.tendsto_iff basis]
+  · rw [basis'.tendsto_iff Basis]
     suffices ∀ U ∈ B', ∃ V W, (V ∈ B' ∧ W ∈ B') ∧ ∀ a b, a ∈ V → b ∈ W → a * b ∈ U by simpa
     intro U U_in
     rcases B.mul U_in with ⟨V, V_in, hV⟩
@@ -334,11 +334,11 @@ instance (priority := 100) is_topologicalRing {R : Type u} [Ring R] (B : RingFil
     intro a b a_in b_in
     exact hV ⟨a, b, a_in, b_in, rfl⟩
   · intro x₀
-    rw [basis.tendsto_iff basis]
+    rw [basis.tendsto_iff Basis]
     intro U
     simpa using B.mul_left x₀
   · intro x₀
-    rw [basis.tendsto_iff basis]
+    rw [basis.tendsto_iff Basis]
     intro U
     simpa using B.mul_right x₀
 #align ring_filter_basis.is_topological_ring RingFilterBasis.is_topologicalRing

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

• add TopologicalSpace.nhds_mkOfNhds_of_hasBasis
• add Trans instance for Filter.mem_of_superset
• change assumptions of TopologicalSpace.nhds_mkOfNhds, golf
  • the new assumption is equivalent to the old one with t ⊆ s removed
  • but is formulated in terms of Filter.Eventually

@@ -178,26 +178,18 @@ def topology (B : GroupFilterBasis G) : TopologicalSpace G :=
 
 @[to_additive]
 theorem nhds_eq (B : GroupFilterBasis G) {x₀ : G} : @nhds G B.topology x₀ = B.N x₀ := by
-  rw [TopologicalSpace.nhds_mkOfNhds]
-  · intro x U U_in
-    rw [(B.hasBasis x).mem_iff] at U_in
-    rcases U_in with ⟨V, V_in, H⟩
-    simpa [mem_pure] using H (mem_image_of_mem _ (GroupFilterBasis.one V_in))
-  · intro x U U_in
-    rw [(B.hasBasis x).mem_iff] at U_in
-    rcases U_in with ⟨V, V_in, H⟩
-    rcases GroupFilterBasis.mul V_in with ⟨W, W_in, hW⟩
-    use (fun y ↦ x * y) '' W, image_mem_map (FilterBasis.mem_filter_of_mem _ W_in)
-    constructor
-    · rw [image_subset_iff] at H ⊢
-      exact ((B.subset_mul_self W_in).trans hW).trans H
-    · rintro y ⟨t, tW, rfl⟩
-      rw [(B.hasBasis _).mem_iff]
-      use W, W_in
-      apply Subset.trans _ H
-      clear H
-      rintro z ⟨w, wW, rfl⟩
-      exact ⟨t * w, hW (mul_mem_mul tW wW), by simp [mul_assoc]⟩
+  apply TopologicalSpace.nhds_mkOfNhds_of_hasBasis (fun x ↦ (FilterBasis.hasBasis _).map _)
+  · intro a U U_in
+    exact ⟨1, B.one U_in, mul_one a⟩
+  · intro a U U_in
+    rcases GroupFilterBasis.mul U_in with ⟨V, V_in, hVU⟩
+    filter_upwards [image_mem_map (B.mem_filter_of_mem V_in)]
+    rintro _ ⟨x, hx, rfl⟩
+    calc
+      a • U ⊇ a • (V * V) := smul_set_mono hVU
+      _ ⊇ a • x • V := smul_set_mono <| smul_set_subset_smul hx
+      _ = (a * x) • V := smul_smul ..
+      _ ∈ (a * x) • B.filter := smul_set_mem_smul_filter <| B.mem_filter_of_mem V_in
 #align group_filter_basis.nhds_eq GroupFilterBasis.nhds_eq
 #align add_group_filter_basis.nhds_eq AddGroupFilterBasis.nhds_eq
 

• Redefine Set.image2 to use ∃ a ∈ s, ∃ b ∈ t, f a b = c instead of ∃ a b, a ∈ s ∧ b ∈ t ∧ f a b = c.
• Redefine Set.seq as Set.image2. The new definition is equal to the old one but rw [Set.seq] gives a different result.
• Redefine Filter.map₂ to use ∃ u ∈ f, ∃ v ∈ g, image2 m u v ⊆ s instead of ∃ u v, u ∈ f ∧ v ∈ g ∧ ...
• Update lemmas like Set.mem_image2, Finset.mem_image₂, Set.mem_mul, Finset.mem_div etc

The two reasons to make the change are:

• ∃ a ∈ s, ∃ b ∈ t, _ is a simp-normal form, and
• it looks a bit nicer.

@@ -141,7 +141,7 @@ instance : Inhabited (GroupFilterBasis G) := ⟨by
 
 @[to_additive]
 theorem subset_mul_self (B : GroupFilterBasis G) {U : Set G} (h : U ∈ B) : U ⊆ U * U :=
-  fun x x_in ↦ ⟨1, x, one h, x_in, one_mul x⟩
+  fun x x_in ↦ ⟨1, one h, x, x_in, one_mul x⟩
 #align group_filter_basis.prod_subset_self GroupFilterBasis.subset_mul_self
 #align add_group_filter_basis.sum_subset_self AddGroupFilterBasis.subset_add_self
 
@@ -372,7 +372,7 @@ instance [DiscreteTopology R] : Inhabited (ModuleFilterBasis R M) :=
       smul' := by
         rintro U (rfl : U ∈ {{(0 : M)}})
         use univ, univ_mem, {0}, rfl
-        rintro a ⟨x, m, -, rfl, rfl⟩
+        rintro a ⟨x, -, m, rfl, rfl⟩
         simp only [smul_zero, mem_singleton_iff]
       smul_left' := by
         rintro x₀ U (h : U ∈ {{(0 : M)}})

... to subset_mul_self

@@ -140,10 +140,10 @@ instance : Inhabited (GroupFilterBasis G) := ⟨by
     simp⟩
 
 @[to_additive]
-theorem prod_subset_self (B : GroupFilterBasis G) {U : Set G} (h : U ∈ B) : U ⊆ U * U :=
+theorem subset_mul_self (B : GroupFilterBasis G) {U : Set G} (h : U ∈ B) : U ⊆ U * U :=
   fun x x_in ↦ ⟨1, x, one h, x_in, one_mul x⟩
-#align group_filter_basis.prod_subset_self GroupFilterBasis.prod_subset_self
-#align add_group_filter_basis.sum_subset_self AddGroupFilterBasis.sum_subset_self
+#align group_filter_basis.prod_subset_self GroupFilterBasis.subset_mul_self
+#align add_group_filter_basis.sum_subset_self AddGroupFilterBasis.subset_add_self
 
 /-- The neighborhood function of a `GroupFilterBasis`. -/
 @[to_additive "The neighborhood function of an `AddGroupFilterBasis`."]
@@ -190,7 +190,7 @@ theorem nhds_eq (B : GroupFilterBasis G) {x₀ : G} : @nhds G B.topology x₀ =
     use (fun y ↦ x * y) '' W, image_mem_map (FilterBasis.mem_filter_of_mem _ W_in)
     constructor
     · rw [image_subset_iff] at H ⊢
-      exact ((B.prod_subset_self W_in).trans hW).trans H
+      exact ((B.subset_mul_self W_in).trans hW).trans H
     · rintro y ⟨t, tW, rfl⟩
       rw [(B.hasBasis _).mem_iff]
       use W, W_in

@@ -251,7 +251,7 @@ instance (priority := 100) isTopologicalGroup (B : GroupFilterBasis G) :
     rcases mul U_in with ⟨V, V_in, hV⟩
     refine' ⟨V, V, ⟨V_in, V_in⟩, _⟩
     intro a b a_in b_in
-    exact hV ⟨a, b, a_in, b_in, rfl⟩
+    exact hV <| mul_mem_mul a_in b_in
   · rw [basis.tendsto_iff basis]
     intro U U_in
     simpa using inv U_in
@@ -318,7 +318,7 @@ instance (priority := 100) isTopologicalRing {R : Type u} [Ring R] (B : RingFilt
     rcases B.mul U_in with ⟨V, V_in, hV⟩
     refine' ⟨V, V, ⟨V_in, V_in⟩, _⟩
     intro a b a_in b_in
-    exact hV ⟨a, b, a_in, b_in, rfl⟩
+    exact hV <| mul_mem_mul a_in b_in
   · intro x₀
     rw [basis.tendsto_iff basis]
     intro U

Search for [∀∃].*(_ and manually replace some occurrences with more readable versions. In case of ∀, the new expressions are defeq to the old ones. In case of ∃, they differ by exists_prop.

In some rare cases, golf proofs that needed fixing.

@@ -409,8 +409,8 @@ But it turns out it's just easier to get it as a byproduct of the proof, so this
 quality-of-life improvement. -/
 theorem _root_.ContinuousSMul.of_basis_zero {ι : Type*} [TopologicalRing R] [TopologicalSpace M]
     [TopologicalAddGroup M] {p : ι → Prop} {b : ι → Set M} (h : HasBasis (𝓝 0) p b)
-    (hsmul : ∀ {i}, p i → ∃ V ∈ 𝓝 (0 : R), ∃ (j : _) (_ : p j), V • b j ⊆ b i)
-    (hsmul_left : ∀ (x₀ : R) {i}, p i → ∃ (j : _) (_ : p j), b j ⊆ (fun x ↦ x₀ • x) ⁻¹' b i)
+    (hsmul : ∀ {i}, p i → ∃ V ∈ 𝓝 (0 : R), ∃ j, p j ∧ V • b j ⊆ b i)
+    (hsmul_left : ∀ (x₀ : R) {i}, p i → ∃ j, p j ∧ MapsTo (x₀ • ·) (b j) (b i))
     (hsmul_right : ∀ (m₀ : M) {i}, p i → ∀ᶠ x in 𝓝 (0 : R), x • m₀ ∈ b i) : ContinuousSMul R M := by
   apply ContinuousSMul.of_nhds_zero
   · rw [h.tendsto_right_iff]

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

This has nice performance benefits.

@@ -70,7 +70,7 @@ attribute [to_additive existing] GroupFilterBasis GroupFilterBasis.conj'
 
 /-- `GroupFilterBasis` constructor in the commutative group case. -/
 @[to_additive "`AddGroupFilterBasis` constructor in the additive commutative group case."]
-def groupFilterBasisOfComm {G : Type _} [CommGroup G] (sets : Set (Set G))
+def groupFilterBasisOfComm {G : Type*} [CommGroup G] (sets : Set (Set G))
     (nonempty : sets.Nonempty) (inter_sets : ∀ x y, x ∈ sets → y ∈ sets → ∃ z ∈ sets, z ⊆ x ∩ y)
     (one : ∀ U ∈ sets, (1 : G) ∈ U) (mul : ∀ U ∈ sets, ∃ V ∈ sets, V * V ⊆ U)
     (inv : ∀ U ∈ sets, ∃ V ∈ sets, V ⊆ (fun x ↦ x⁻¹) ⁻¹' U) : GroupFilterBasis G :=
@@ -335,7 +335,7 @@ end RingFilterBasis
   Example : if `M` is a topological module then the neighbourhoods of zero are a
   `ModuleFilterBasis`. Conversely given a `ModuleFilterBasis` one can define a topology
   compatible with the module structure on `M`. -/
-structure ModuleFilterBasis (R M : Type _) [CommRing R] [TopologicalSpace R] [AddCommGroup M]
+structure ModuleFilterBasis (R M : Type*) [CommRing R] [TopologicalSpace R] [AddCommGroup M]
   [Module R M] extends AddGroupFilterBasis M where
   smul' : ∀ {U}, U ∈ sets → ∃ V ∈ 𝓝 (0 : R), ∃ W ∈ sets, V • W ⊆ U
   smul_left' : ∀ (x₀ : R) {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x ↦ x₀ • x) ⁻¹' U
@@ -344,7 +344,7 @@ structure ModuleFilterBasis (R M : Type _) [CommRing R] [TopologicalSpace R] [Ad
 
 namespace ModuleFilterBasis
 
-variable {R M : Type _} [CommRing R] [TopologicalSpace R] [AddCommGroup M] [Module R M]
+variable {R M : Type*} [CommRing R] [TopologicalSpace R] [AddCommGroup M] [Module R M]
   (B : ModuleFilterBasis R M)
 
 instance GroupFilterBasis.hasMem : Membership (Set M) (ModuleFilterBasis R M) :=
@@ -393,7 +393,7 @@ def topology : TopologicalSpace M :=
 /-- The topology associated to a module filter basis on a module over a topological ring.
 It has the given basis as a basis of neighborhoods of zero. This version gets the ring
 topology by unification instead of type class inference. -/
-def topology' {R M : Type _} [CommRing R] {_ : TopologicalSpace R} [AddCommGroup M] [Module R M]
+def topology' {R M : Type*} [CommRing R] {_ : TopologicalSpace R} [AddCommGroup M] [Module R M]
     (B : ModuleFilterBasis R M) : TopologicalSpace M :=
   B.toAddGroupFilterBasis.topology
 #align module_filter_basis.topology' ModuleFilterBasis.topology'
@@ -407,7 +407,7 @@ by their neighborhoods of 0 to obtain the `ContinuousSMul` on the pre-existing t
 
 But it turns out it's just easier to get it as a byproduct of the proof, so this is just a free
 quality-of-life improvement. -/
-theorem _root_.ContinuousSMul.of_basis_zero {ι : Type _} [TopologicalRing R] [TopologicalSpace M]
+theorem _root_.ContinuousSMul.of_basis_zero {ι : Type*} [TopologicalRing R] [TopologicalSpace M]
     [TopologicalAddGroup M] {p : ι → Prop} {b : ι → Set M} (h : HasBasis (𝓝 0) p b)
     (hsmul : ∀ {i}, p i → ∃ V ∈ 𝓝 (0 : R), ∃ (j : _) (_ : p j), V • b j ⊆ b i)
     (hsmul_left : ∀ (x₀ : R) {i}, p i → ∃ (j : _) (_ : p j), b j ⊆ (fun x ↦ x₀ • x) ⁻¹' b i)
@@ -443,7 +443,7 @@ instance (priority := 100) continuousSMul [TopologicalRing R] :
 #align module_filter_basis.has_continuous_smul ModuleFilterBasis.continuousSMul
 
 /-- Build a module filter basis from compatible ring and additive group filter bases. -/
-def ofBases {R M : Type _} [CommRing R] [AddCommGroup M] [Module R M] (BR : RingFilterBasis R)
+def ofBases {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M] (BR : RingFilterBasis R)
     (BM : AddGroupFilterBasis M) (smul : ∀ {U}, U ∈ BM → ∃ V ∈ BR, ∃ W ∈ BM, V • W ⊆ U)
     (smul_left : ∀ (x₀ : R) {U}, U ∈ BM → ∃ V ∈ BM, V ⊆ (fun x ↦ x₀ • x) ⁻¹' U)
     (smul_right : ∀ (m₀ : M) {U}, U ∈ BM → ∃ V ∈ BR, V ⊆ (fun x ↦ x • m₀) ⁻¹' U) :

• 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) 2021 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot
-
-! This file was ported from Lean 3 source module topology.algebra.filter_basis
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.Filter.Bases
 import Mathlib.Topology.Algebra.Module.Basic
 
+#align_import topology.algebra.filter_basis from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
+
 /-!
 # Group and ring filter bases
 

Changes are of the form

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

@@ -192,7 +192,7 @@ theorem nhds_eq (B : GroupFilterBasis G) {x₀ : G} : @nhds G B.topology x₀ =
     rcases GroupFilterBasis.mul V_in with ⟨W, W_in, hW⟩
     use (fun y ↦ x * y) '' W, image_mem_map (FilterBasis.mem_filter_of_mem _ W_in)
     constructor
-    · rw [image_subset_iff] at H⊢
+    · rw [image_subset_iff] at H ⊢
       exact ((B.prod_subset_self W_in).trans hW).trans H
     · rintro y ⟨t, tW, rfl⟩
       rw [(B.hasBasis _).mem_iff]

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com> Co-authored-by: Chris Hughes <chrishughes24@gmail.com> Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>