topology.algebra.with_zero_topology ⟷ Mathlib.Topology.Algebra.WithZeroTopology

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

@@ -45,7 +45,7 @@ namespace WithZeroTopology
 variable {α Γ₀ : Type _} [LinearOrderedCommGroupWithZero Γ₀] {γ γ₁ γ₂ : Γ₀} {l : Filter α}
   {f : α → Γ₀}
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 #print WithZeroTopology.topologicalSpace /-
 /-- The topology on a linearly ordered commutative group with a zero element adjoined.
 A subset U is open if 0 ∉ U or if there is an invertible element γ₀ such that {γ | γ < γ₀} ⊆ U. -/
@@ -56,7 +56,7 @@ protected def topologicalSpace : TopologicalSpace Γ₀ :=
 
 attribute [scoped instance] WithZeroTopology.topologicalSpace
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 #print WithZeroTopology.nhds_eq_update /-
 theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ)) :=
   funext <| nhds_mkOfNhds_single <| le_iInf₂ fun γ h₀ => le_principal_iff.2 <| zero_lt_iff.2 h₀
@@ -68,7 +68,7 @@ theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (
 -/
 
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 #print WithZeroTopology.nhds_zero /-
 theorem nhds_zero : 𝓝 (0 : Γ₀) = ⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ) := by rw [nhds_eq_update, update_same]
 #align with_zero_topology.nhds_zero WithZeroTopology.nhds_zero
@@ -99,7 +99,7 @@ theorem nhds_zero_of_units (γ : Γ₀ˣ) : Iio ↑γ ∈ 𝓝 (0 : Γ₀) :=
 #align with_zero_topology.nhds_zero_of_units WithZeroTopology.nhds_zero_of_units
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (γ₀ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (γ₀ «expr ≠ » 0) -/
 #print WithZeroTopology.tendsto_zero /-
 theorem tendsto_zero : Tendsto f l (𝓝 (0 : Γ₀)) ↔ ∀ (γ₀) (_ : γ₀ ≠ 0), ∀ᶠ x in l, f x < γ₀ := by
   simp [nhds_zero]
@@ -178,7 +178,7 @@ theorem Iio_mem_nhds (h : γ₁ < γ₂) : Iio γ₂ ∈ 𝓝 γ₁ := by
 -/
 
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 #print WithZeroTopology.isOpen_iff /-
 theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ : _) (_ : γ ≠ 0), Iio γ ⊆ s :=
   by
@@ -188,7 +188,7 @@ theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ
 #align with_zero_topology.is_open_iff WithZeroTopology.isOpen_iff
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 #print WithZeroTopology.isClosed_iff /-
 theorem isClosed_iff {s : Set Γ₀} : IsClosed s ↔ (0 : Γ₀) ∈ s ∨ ∃ (γ : _) (_ : γ ≠ 0), s ⊆ Ici γ :=
   by
@@ -266,7 +266,7 @@ protected theorem continuousMul : ContinuousMul Γ₀ :=
       refine' ⟨γ / y, div_ne_zero hγ hy, fun x hx => _⟩
       calc
         x * y < γ / y * y := mul_lt_right₀ _ hx hy
-        _ = γ := div_mul_cancel _ hy
+        _ = γ := div_mul_cancel₀ _ hy
     · have hy : y ≠ 0 := ((zero_lt_iff.mpr hx).trans_le hle).ne'
       rw [ContinuousAt, nhds_prod_eq, nhds_of_ne_zero hx, nhds_of_ne_zero hy, prod_pure_pure]
       exact pure_le_nhds (x * y)⟩

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

@@ -229,7 +229,7 @@ attribute [scoped instance] WithZeroTopology.orderClosedTopology
 theorem t3Space : T3Space Γ₀ :=
   {
     to_regularSpace :=
-      RegularSpace.ofLift'_closure fun γ =>
+      RegularSpace.of_lift'_closure fun γ =>
         by
         rcases ne_or_eq γ 0 with (h₀ | rfl)
         ·

mathlib commit https://github.com/leanprover-community/mathlib/commit/3365b20c2ffa7c35e47e5209b89ba9abdddf3ffe

@@ -81,7 +81,7 @@ theorem hasBasis_nhds_zero : (𝓝 (0 : Γ₀)).HasBasis (fun γ : Γ₀ => γ 
   by
   rw [nhds_zero]
   refine' has_basis_binfi_principal _ ⟨1, one_ne_zero⟩
-  exact directedOn_iff_directed.2 (directed_of_inf fun a b hab => Iio_subset_Iio hab)
+  exact directedOn_iff_directed.2 (directed_of_isDirected_ge fun a b hab => Iio_subset_Iio hab)
 #align with_zero_topology.has_basis_nhds_zero WithZeroTopology.hasBasis_nhds_zero
 -/
 

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.Algebra.Order.WithZero
-import Mathbin.Topology.Algebra.Order.Field
+import Algebra.Order.WithZero
+import Topology.Algebra.Order.Field
 
 #align_import topology.algebra.with_zero_topology from "leanprover-community/mathlib"@"932872382355f00112641d305ba0619305dc8642"
 
@@ -45,7 +45,7 @@ namespace WithZeroTopology
 variable {α Γ₀ : Type _} [LinearOrderedCommGroupWithZero Γ₀] {γ γ₁ γ₂ : Γ₀} {l : Filter α}
   {f : α → Γ₀}
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 #print WithZeroTopology.topologicalSpace /-
 /-- The topology on a linearly ordered commutative group with a zero element adjoined.
 A subset U is open if 0 ∉ U or if there is an invertible element γ₀ such that {γ | γ < γ₀} ⊆ U. -/
@@ -56,7 +56,7 @@ protected def topologicalSpace : TopologicalSpace Γ₀ :=
 
 attribute [scoped instance] WithZeroTopology.topologicalSpace
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 #print WithZeroTopology.nhds_eq_update /-
 theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ)) :=
   funext <| nhds_mkOfNhds_single <| le_iInf₂ fun γ h₀ => le_principal_iff.2 <| zero_lt_iff.2 h₀
@@ -68,7 +68,7 @@ theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (
 -/
 
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 #print WithZeroTopology.nhds_zero /-
 theorem nhds_zero : 𝓝 (0 : Γ₀) = ⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ) := by rw [nhds_eq_update, update_same]
 #align with_zero_topology.nhds_zero WithZeroTopology.nhds_zero
@@ -99,7 +99,7 @@ theorem nhds_zero_of_units (γ : Γ₀ˣ) : Iio ↑γ ∈ 𝓝 (0 : Γ₀) :=
 #align with_zero_topology.nhds_zero_of_units WithZeroTopology.nhds_zero_of_units
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ₀ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (γ₀ «expr ≠ » 0) -/
 #print WithZeroTopology.tendsto_zero /-
 theorem tendsto_zero : Tendsto f l (𝓝 (0 : Γ₀)) ↔ ∀ (γ₀) (_ : γ₀ ≠ 0), ∀ᶠ x in l, f x < γ₀ := by
   simp [nhds_zero]
@@ -178,7 +178,7 @@ theorem Iio_mem_nhds (h : γ₁ < γ₂) : Iio γ₂ ∈ 𝓝 γ₁ := by
 -/
 
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 #print WithZeroTopology.isOpen_iff /-
 theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ : _) (_ : γ ≠ 0), Iio γ ⊆ s :=
   by
@@ -188,7 +188,7 @@ theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ
 #align with_zero_topology.is_open_iff WithZeroTopology.isOpen_iff
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 #print WithZeroTopology.isClosed_iff /-
 theorem isClosed_iff {s : Set Γ₀} : IsClosed s ↔ (0 : Γ₀) ∈ s ∨ ∃ (γ : _) (_ : γ ≠ 0), s ⊆ Ici γ :=
   by

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.with_zero_topology
-! leanprover-community/mathlib commit 932872382355f00112641d305ba0619305dc8642
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Order.WithZero
 import Mathbin.Topology.Algebra.Order.Field
 
+#align_import topology.algebra.with_zero_topology from "leanprover-community/mathlib"@"932872382355f00112641d305ba0619305dc8642"
+
 /-!
 # The topology on linearly ordered commutative groups with zero
 
@@ -48,7 +45,7 @@ namespace WithZeroTopology
 variable {α Γ₀ : Type _} [LinearOrderedCommGroupWithZero Γ₀] {γ γ₁ γ₂ : Γ₀} {l : Filter α}
   {f : α → Γ₀}
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 #print WithZeroTopology.topologicalSpace /-
 /-- The topology on a linearly ordered commutative group with a zero element adjoined.
 A subset U is open if 0 ∉ U or if there is an invertible element γ₀ such that {γ | γ < γ₀} ⊆ U. -/
@@ -59,7 +56,7 @@ protected def topologicalSpace : TopologicalSpace Γ₀ :=
 
 attribute [scoped instance] WithZeroTopology.topologicalSpace
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 #print WithZeroTopology.nhds_eq_update /-
 theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ)) :=
   funext <| nhds_mkOfNhds_single <| le_iInf₂ fun γ h₀ => le_principal_iff.2 <| zero_lt_iff.2 h₀
@@ -71,7 +68,7 @@ theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (
 -/
 
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 #print WithZeroTopology.nhds_zero /-
 theorem nhds_zero : 𝓝 (0 : Γ₀) = ⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ) := by rw [nhds_eq_update, update_same]
 #align with_zero_topology.nhds_zero WithZeroTopology.nhds_zero
@@ -102,7 +99,7 @@ theorem nhds_zero_of_units (γ : Γ₀ˣ) : Iio ↑γ ∈ 𝓝 (0 : Γ₀) :=
 #align with_zero_topology.nhds_zero_of_units WithZeroTopology.nhds_zero_of_units
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ₀ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ₀ «expr ≠ » 0) -/
 #print WithZeroTopology.tendsto_zero /-
 theorem tendsto_zero : Tendsto f l (𝓝 (0 : Γ₀)) ↔ ∀ (γ₀) (_ : γ₀ ≠ 0), ∀ᶠ x in l, f x < γ₀ := by
   simp [nhds_zero]
@@ -181,7 +178,7 @@ theorem Iio_mem_nhds (h : γ₁ < γ₂) : Iio γ₂ ∈ 𝓝 γ₁ := by
 -/
 
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 #print WithZeroTopology.isOpen_iff /-
 theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ : _) (_ : γ ≠ 0), Iio γ ⊆ s :=
   by
@@ -191,7 +188,7 @@ theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ
 #align with_zero_topology.is_open_iff WithZeroTopology.isOpen_iff
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 #print WithZeroTopology.isClosed_iff /-
 theorem isClosed_iff {s : Set Γ₀} : IsClosed s ↔ (0 : Γ₀) ∈ s ∨ ∃ (γ : _) (_ : γ ≠ 0), s ⊆ Ici γ :=
   by

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

@@ -60,9 +60,11 @@ protected def topologicalSpace : TopologicalSpace Γ₀ :=
 attribute [scoped instance] WithZeroTopology.topologicalSpace
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+#print WithZeroTopology.nhds_eq_update /-
 theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ)) :=
   funext <| nhds_mkOfNhds_single <| le_iInf₂ fun γ h₀ => le_principal_iff.2 <| zero_lt_iff.2 h₀
 #align with_zero_topology.nhds_eq_update WithZeroTopology.nhds_eq_update
+-/
 
 /-!
 ### Neighbourhoods of zero
@@ -70,9 +72,12 @@ theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (
 
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+#print WithZeroTopology.nhds_zero /-
 theorem nhds_zero : 𝓝 (0 : Γ₀) = ⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ) := by rw [nhds_eq_update, update_same]
 #align with_zero_topology.nhds_zero WithZeroTopology.nhds_zero
+-/
 
+#print WithZeroTopology.hasBasis_nhds_zero /-
 /-- In a linearly ordered group with zero element adjoined, `U` is a neighbourhood of `0` if and
 only if there exists a nonzero element `γ₀` such that `Iio γ₀ ⊆ U`. -/
 theorem hasBasis_nhds_zero : (𝓝 (0 : Γ₀)).HasBasis (fun γ : Γ₀ => γ ≠ 0) Iio :=
@@ -81,33 +86,42 @@ theorem hasBasis_nhds_zero : (𝓝 (0 : Γ₀)).HasBasis (fun γ : Γ₀ => γ 
   refine' has_basis_binfi_principal _ ⟨1, one_ne_zero⟩
   exact directedOn_iff_directed.2 (directed_of_inf fun a b hab => Iio_subset_Iio hab)
 #align with_zero_topology.has_basis_nhds_zero WithZeroTopology.hasBasis_nhds_zero
+-/
 
+#print WithZeroTopology.Iio_mem_nhds_zero /-
 theorem Iio_mem_nhds_zero (hγ : γ ≠ 0) : Iio γ ∈ 𝓝 (0 : Γ₀) :=
   hasBasis_nhds_zero.mem_of_mem hγ
 #align with_zero_topology.Iio_mem_nhds_zero WithZeroTopology.Iio_mem_nhds_zero
+-/
 
+#print WithZeroTopology.nhds_zero_of_units /-
 /-- If `γ` is an invertible element of a linearly ordered group with zero element adjoined, then
 `Iio (γ : Γ₀)` is a neighbourhood of `0`. -/
 theorem nhds_zero_of_units (γ : Γ₀ˣ) : Iio ↑γ ∈ 𝓝 (0 : Γ₀) :=
   Iio_mem_nhds_zero γ.NeZero
 #align with_zero_topology.nhds_zero_of_units WithZeroTopology.nhds_zero_of_units
+-/
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ₀ «expr ≠ » 0) -/
+#print WithZeroTopology.tendsto_zero /-
 theorem tendsto_zero : Tendsto f l (𝓝 (0 : Γ₀)) ↔ ∀ (γ₀) (_ : γ₀ ≠ 0), ∀ᶠ x in l, f x < γ₀ := by
   simp [nhds_zero]
 #align with_zero_topology.tendsto_zero WithZeroTopology.tendsto_zero
+-/
 
 /-!
 ### Neighbourhoods of non-zero elements
 -/
 
 
+#print WithZeroTopology.nhds_of_ne_zero /-
 /-- The neighbourhood filter of a nonzero element consists of all sets containing that
 element. -/
 @[simp]
 theorem nhds_of_ne_zero {γ : Γ₀} (h₀ : γ ≠ 0) : 𝓝 γ = pure γ := by
   rw [nhds_eq_update, update_noteq h₀]
 #align with_zero_topology.nhds_of_ne_zero WithZeroTopology.nhds_of_ne_zero
+-/
 
 #print WithZeroTopology.nhds_coe_units /-
 /-- The neighbourhood filter of an invertible element consists of all sets containing that
@@ -124,15 +138,19 @@ theorem singleton_mem_nhds_of_units (γ : Γ₀ˣ) : ({γ} : Set Γ₀) ∈ 𝓝
 #align with_zero_topology.singleton_mem_nhds_of_units WithZeroTopology.singleton_mem_nhds_of_units
 -/
 
+#print WithZeroTopology.singleton_mem_nhds_of_ne_zero /-
 /-- If `γ` is a nonzero element of a linearly ordered group with zero element adjoined, then `{γ}`
 is a neighbourhood of `γ`. -/
 theorem singleton_mem_nhds_of_ne_zero (h : γ ≠ 0) : ({γ} : Set Γ₀) ∈ 𝓝 (γ : Γ₀) := by simp [h]
 #align with_zero_topology.singleton_mem_nhds_of_ne_zero WithZeroTopology.singleton_mem_nhds_of_ne_zero
+-/
 
+#print WithZeroTopology.hasBasis_nhds_of_ne_zero /-
 theorem hasBasis_nhds_of_ne_zero {x : Γ₀} (h : x ≠ 0) :
     HasBasis (𝓝 x) (fun i : Unit => True) fun i => {x} := by rw [nhds_of_ne_zero h];
   exact has_basis_pure _
 #align with_zero_topology.has_basis_nhds_of_ne_zero WithZeroTopology.hasBasis_nhds_of_ne_zero
+-/
 
 #print WithZeroTopology.hasBasis_nhds_units /-
 theorem hasBasis_nhds_units (γ : Γ₀ˣ) : HasBasis (𝓝 (γ : Γ₀)) (fun i : Unit => True) fun i => {γ} :=
@@ -140,9 +158,11 @@ theorem hasBasis_nhds_units (γ : Γ₀ˣ) : HasBasis (𝓝 (γ : Γ₀)) (fun i
 #align with_zero_topology.has_basis_nhds_units WithZeroTopology.hasBasis_nhds_units
 -/
 
+#print WithZeroTopology.tendsto_of_ne_zero /-
 theorem tendsto_of_ne_zero {γ : Γ₀} (h : γ ≠ 0) : Tendsto f l (𝓝 γ) ↔ ∀ᶠ x in l, f x = γ := by
   rw [nhds_of_ne_zero h, tendsto_pure]
 #align with_zero_topology.tendsto_of_ne_zero WithZeroTopology.tendsto_of_ne_zero
+-/
 
 #print WithZeroTopology.tendsto_units /-
 theorem tendsto_units {γ₀ : Γ₀ˣ} : Tendsto f l (𝓝 (γ₀ : Γ₀)) ↔ ∀ᶠ x in l, f x = γ₀ :=
@@ -162,19 +182,23 @@ theorem Iio_mem_nhds (h : γ₁ < γ₂) : Iio γ₂ ∈ 𝓝 γ₁ := by
 
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+#print WithZeroTopology.isOpen_iff /-
 theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ : _) (_ : γ ≠ 0), Iio γ ⊆ s :=
   by
   rw [isOpen_iff_mem_nhds, ← and_forall_ne (0 : Γ₀)]
   simp (config := { contextual := true }) [nhds_of_ne_zero, imp_iff_not_or,
     has_basis_nhds_zero.mem_iff]
 #align with_zero_topology.is_open_iff WithZeroTopology.isOpen_iff
+-/
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+#print WithZeroTopology.isClosed_iff /-
 theorem isClosed_iff {s : Set Γ₀} : IsClosed s ↔ (0 : Γ₀) ∈ s ∨ ∃ (γ : _) (_ : γ ≠ 0), s ⊆ Ici γ :=
   by
   simp only [← isOpen_compl_iff, is_open_iff, mem_compl_iff, Classical.not_not, ← compl_Ici,
     compl_subset_compl]
 #align with_zero_topology.is_closed_iff WithZeroTopology.isClosed_iff
+-/
 
 #print WithZeroTopology.isOpen_Iio /-
 theorem isOpen_Iio {a : Γ₀} : IsOpen (Iio a) :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

@@ -246,7 +246,6 @@ protected theorem continuousMul : ContinuousMul Γ₀ :=
       calc
         x * y < γ / y * y := mul_lt_right₀ _ hx hy
         _ = γ := div_mul_cancel _ hy
-        
     · have hy : y ≠ 0 := ((zero_lt_iff.mpr hx).trans_le hle).ne'
       rw [ContinuousAt, nhds_prod_eq, nhds_of_ne_zero hx, nhds_of_ne_zero hy, prod_pure_pure]
       exact pure_le_nhds (x * y)⟩

mathlib commit https://github.com/leanprover-community/mathlib/commit/31c24aa72e7b3e5ed97a8412470e904f82b81004

@@ -48,7 +48,7 @@ namespace WithZeroTopology
 variable {α Γ₀ : Type _} [LinearOrderedCommGroupWithZero Γ₀] {γ γ₁ γ₂ : Γ₀} {l : Filter α}
   {f : α → Γ₀}
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 #print WithZeroTopology.topologicalSpace /-
 /-- The topology on a linearly ordered commutative group with a zero element adjoined.
 A subset U is open if 0 ∉ U or if there is an invertible element γ₀ such that {γ | γ < γ₀} ⊆ U. -/
@@ -59,7 +59,7 @@ protected def topologicalSpace : TopologicalSpace Γ₀ :=
 
 attribute [scoped instance] WithZeroTopology.topologicalSpace
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ)) :=
   funext <| nhds_mkOfNhds_single <| le_iInf₂ fun γ h₀ => le_principal_iff.2 <| zero_lt_iff.2 h₀
 #align with_zero_topology.nhds_eq_update WithZeroTopology.nhds_eq_update
@@ -69,7 +69,7 @@ theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (
 -/
 
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem nhds_zero : 𝓝 (0 : Γ₀) = ⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ) := by rw [nhds_eq_update, update_same]
 #align with_zero_topology.nhds_zero WithZeroTopology.nhds_zero
 
@@ -92,7 +92,7 @@ theorem nhds_zero_of_units (γ : Γ₀ˣ) : Iio ↑γ ∈ 𝓝 (0 : Γ₀) :=
   Iio_mem_nhds_zero γ.NeZero
 #align with_zero_topology.nhds_zero_of_units WithZeroTopology.nhds_zero_of_units
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ₀ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ₀ «expr ≠ » 0) -/
 theorem tendsto_zero : Tendsto f l (𝓝 (0 : Γ₀)) ↔ ∀ (γ₀) (_ : γ₀ ≠ 0), ∀ᶠ x in l, f x < γ₀ := by
   simp [nhds_zero]
 #align with_zero_topology.tendsto_zero WithZeroTopology.tendsto_zero
@@ -161,7 +161,7 @@ theorem Iio_mem_nhds (h : γ₁ < γ₂) : Iio γ₂ ∈ 𝓝 γ₁ := by
 -/
 
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ : _) (_ : γ ≠ 0), Iio γ ⊆ s :=
   by
   rw [isOpen_iff_mem_nhds, ← and_forall_ne (0 : Γ₀)]
@@ -169,7 +169,7 @@ theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ
     has_basis_nhds_zero.mem_iff]
 #align with_zero_topology.is_open_iff WithZeroTopology.isOpen_iff
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem isClosed_iff {s : Set Γ₀} : IsClosed s ↔ (0 : Γ₀) ∈ s ∨ ∃ (γ : _) (_ : γ ≠ 0), s ⊆ Ici γ :=
   by
   simp only [← isOpen_compl_iff, is_open_iff, mem_compl_iff, Classical.not_not, ← compl_Ici,

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

@@ -162,7 +162,7 @@ theorem Iio_mem_nhds (h : γ₁ < γ₂) : Iio γ₂ ∈ 𝓝 γ₁ := by
 
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
-theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ : _)(_ : γ ≠ 0), Iio γ ⊆ s :=
+theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ : _) (_ : γ ≠ 0), Iio γ ⊆ s :=
   by
   rw [isOpen_iff_mem_nhds, ← and_forall_ne (0 : Γ₀)]
   simp (config := { contextual := true }) [nhds_of_ne_zero, imp_iff_not_or,
@@ -170,7 +170,7 @@ theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ
 #align with_zero_topology.is_open_iff WithZeroTopology.isOpen_iff
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
-theorem isClosed_iff {s : Set Γ₀} : IsClosed s ↔ (0 : Γ₀) ∈ s ∨ ∃ (γ : _)(_ : γ ≠ 0), s ⊆ Ici γ :=
+theorem isClosed_iff {s : Set Γ₀} : IsClosed s ↔ (0 : Γ₀) ∈ s ∨ ∃ (γ : _) (_ : γ ≠ 0), s ⊆ Ici γ :=
   by
   simp only [← isOpen_compl_iff, is_open_iff, mem_compl_iff, Classical.not_not, ← compl_Ici,
     compl_subset_compl]
@@ -232,7 +232,7 @@ protected theorem continuousMul : ContinuousMul Γ₀ :=
     wlog hle : x ≤ y generalizing x y
     · have := tendsto.comp (this y x (le_of_not_le hle)) (continuous_swap.tendsto (x, y))
       simpa only [mul_comm, Function.comp, Prod.swap]
-    rcases eq_or_ne x 0 with (rfl | hx) <;> [rcases eq_or_ne y 0 with (rfl | hy);skip]
+    rcases eq_or_ne x 0 with (rfl | hx) <;> [rcases eq_or_ne y 0 with (rfl | hy); skip]
     · rw [ContinuousAt, MulZeroClass.zero_mul]
       refine'
         ((has_basis_nhds_zero.prod_nhds has_basis_nhds_zero).tendsto_iffₓ has_basis_nhds_zero).2

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

@@ -39,7 +39,7 @@ linearly ordered commutative group with zero. You can locally activate this topo
 -/
 
 
-open Topology Filter
+open scoped Topology Filter
 
 open TopologicalSpace Filter Set Function
 
@@ -150,9 +150,11 @@ theorem tendsto_units {γ₀ : Γ₀ˣ} : Tendsto f l (𝓝 (γ₀ : Γ₀)) ↔
 #align with_zero_topology.tendsto_units WithZeroTopology.tendsto_units
 -/
 
+#print WithZeroTopology.Iio_mem_nhds /-
 theorem Iio_mem_nhds (h : γ₁ < γ₂) : Iio γ₂ ∈ 𝓝 γ₁ := by
   rcases eq_or_ne γ₁ 0 with (rfl | h₀) <;> simp [*, h.ne', Iio_mem_nhds_zero]
 #align with_zero_topology.Iio_mem_nhds WithZeroTopology.Iio_mem_nhds
+-/
 
 /-!
 ### Open/closed sets

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

@@ -59,12 +59,6 @@ protected def topologicalSpace : TopologicalSpace Γ₀ :=
 
 attribute [scoped instance] WithZeroTopology.topologicalSpace
 
-/- warning: with_zero_topology.nhds_eq_update -> WithZeroTopology.nhds_eq_update is a dubious translation:
-lean 3 declaration is
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Eq.{succ u1} (Γ₀ -> (Filter.{u1} Γ₀)) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1)) (Function.update.{succ u1, succ u1} Γ₀ (fun (a : Γ₀) => Filter.{u1} Γ₀) (fun (a : Γ₀) (b : Γ₀) => Eq.decidable.{u1} Γ₀ (LinearOrderedCommMonoid.toLinearOrder.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))) a b) (Pure.pure.{u1, u1} (fun {Γ₀ : Type.{u1}} => Filter.{u1} Γ₀) Filter.hasPure.{u1} Γ₀) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))))))) (iInf.{u1, succ u1} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.completeLattice.{u1} Γ₀))) Γ₀ (fun (γ : Γ₀) => iInf.{u1, 0} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.completeLattice.{u1} Γ₀))) (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) => Filter.principal.{u1} Γ₀ (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ)))))
-but is expected to have type
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Eq.{succ u1} (Γ₀ -> (Filter.{u1} Γ₀)) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1)) (Function.update.{succ u1, succ u1} Γ₀ (fun (a : Γ₀) => Filter.{u1} Γ₀) (fun (a : Γ₀) (b : Γ₀) => instDecidableEq.{u1} Γ₀ (LinearOrderedCommMonoid.toLinearOrder.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))) a b) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} Γ₀) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))) (iInf.{u1, succ u1} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.instCompleteLatticeFilter.{u1} Γ₀))) Γ₀ (fun (γ : Γ₀) => iInf.{u1, 0} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.instCompleteLatticeFilter.{u1} Γ₀))) (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) => Filter.principal.{u1} Γ₀ (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ)))))
-Case conversion may be inaccurate. Consider using '#align with_zero_topology.nhds_eq_update WithZeroTopology.nhds_eq_updateₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ)) :=
   funext <| nhds_mkOfNhds_single <| le_iInf₂ fun γ h₀ => le_principal_iff.2 <| zero_lt_iff.2 h₀
@@ -75,22 +69,10 @@ theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (
 -/
 
 
-/- warning: with_zero_topology.nhds_zero -> WithZeroTopology.nhds_zero is a dubious translation:
-lean 3 declaration is
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Eq.{succ u1} (Filter.{u1} Γ₀) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (iInf.{u1, succ u1} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.completeLattice.{u1} Γ₀))) Γ₀ (fun (γ : Γ₀) => iInf.{u1, 0} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.completeLattice.{u1} Γ₀))) (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) => Filter.principal.{u1} Γ₀ (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ))))
-but is expected to have type
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Eq.{succ u1} (Filter.{u1} Γ₀) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (iInf.{u1, succ u1} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.instCompleteLatticeFilter.{u1} Γ₀))) Γ₀ (fun (γ : Γ₀) => iInf.{u1, 0} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.instCompleteLatticeFilter.{u1} Γ₀))) (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) => Filter.principal.{u1} Γ₀ (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ))))
-Case conversion may be inaccurate. Consider using '#align with_zero_topology.nhds_zero WithZeroTopology.nhds_zeroₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem nhds_zero : 𝓝 (0 : Γ₀) = ⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ) := by rw [nhds_eq_update, update_same]
 #align with_zero_topology.nhds_zero WithZeroTopology.nhds_zero
 
-/- warning: with_zero_topology.has_basis_nhds_zero -> WithZeroTopology.hasBasis_nhds_zero is a dubious translation:
-lean 3 declaration is
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Filter.HasBasis.{u1, succ u1} Γ₀ Γ₀ (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (fun (γ : Γ₀) => Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))))
-but is expected to have type
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Filter.HasBasis.{u1, succ u1} Γ₀ Γ₀ (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (fun (γ : Γ₀) => Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align with_zero_topology.has_basis_nhds_zero WithZeroTopology.hasBasis_nhds_zeroₓ'. -/
 /-- In a linearly ordered group with zero element adjoined, `U` is a neighbourhood of `0` if and
 only if there exists a nonzero element `γ₀` such that `Iio γ₀ ⊆ U`. -/
 theorem hasBasis_nhds_zero : (𝓝 (0 : Γ₀)).HasBasis (fun γ : Γ₀ => γ ≠ 0) Iio :=
@@ -100,34 +82,16 @@ theorem hasBasis_nhds_zero : (𝓝 (0 : Γ₀)).HasBasis (fun γ : Γ₀ => γ 
   exact directedOn_iff_directed.2 (directed_of_inf fun a b hab => Iio_subset_Iio hab)
 #align with_zero_topology.has_basis_nhds_zero WithZeroTopology.hasBasis_nhds_zero
 
-/- warning: with_zero_topology.Iio_mem_nhds_zero -> WithZeroTopology.Iio_mem_nhds_zero is a dubious translation:
-lean 3 declaration is
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {γ : Γ₀}, (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) -> (Membership.Mem.{u1, u1} (Set.{u1} Γ₀) (Filter.{u1} Γ₀) (Filter.hasMem.{u1} Γ₀) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))))
-but is expected to have type
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {γ : Γ₀}, (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) -> (Membership.mem.{u1, u1} (Set.{u1} Γ₀) (Filter.{u1} Γ₀) (instMembershipSetFilter.{u1} Γ₀) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align with_zero_topology.Iio_mem_nhds_zero WithZeroTopology.Iio_mem_nhds_zeroₓ'. -/
 theorem Iio_mem_nhds_zero (hγ : γ ≠ 0) : Iio γ ∈ 𝓝 (0 : Γ₀) :=
   hasBasis_nhds_zero.mem_of_mem hγ
 #align with_zero_topology.Iio_mem_nhds_zero WithZeroTopology.Iio_mem_nhds_zero
 
-/- warning: with_zero_topology.nhds_zero_of_units -> WithZeroTopology.nhds_zero_of_units is a dubious translation:
-lean 3 declaration is
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] (γ : Units.{u1} Γ₀ (MonoidWithZero.toMonoid.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))), Membership.Mem.{u1, u1} (Set.{u1} Γ₀) (Filter.{u1} Γ₀) (Filter.hasMem.{u1} Γ₀) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} Γ₀ (MonoidWithZero.toMonoid.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))) Γ₀ (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} Γ₀ (MonoidWithZero.toMonoid.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))) Γ₀ (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} Γ₀ (MonoidWithZero.toMonoid.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))) Γ₀ (coeBase.{succ u1, succ u1} (Units.{u1} Γ₀ (MonoidWithZero.toMonoid.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))) Γ₀ (Units.hasCoe.{u1} Γ₀ (MonoidWithZero.toMonoid.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))) γ)) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))))))))
-but is expected to have type
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] (γ : Units.{u1} Γ₀ (MonoidWithZero.toMonoid.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))), Membership.mem.{u1, u1} (Set.{u1} Γ₀) (Filter.{u1} Γ₀) (instMembershipSetFilter.{u1} Γ₀) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (Units.val.{u1} Γ₀ (MonoidWithZero.toMonoid.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))) γ)) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align with_zero_topology.nhds_zero_of_units WithZeroTopology.nhds_zero_of_unitsₓ'. -/
 /-- If `γ` is an invertible element of a linearly ordered group with zero element adjoined, then
 `Iio (γ : Γ₀)` is a neighbourhood of `0`. -/
 theorem nhds_zero_of_units (γ : Γ₀ˣ) : Iio ↑γ ∈ 𝓝 (0 : Γ₀) :=
   Iio_mem_nhds_zero γ.NeZero
 #align with_zero_topology.nhds_zero_of_units WithZeroTopology.nhds_zero_of_units
 
-/- warning: with_zero_topology.tendsto_zero -> WithZeroTopology.tendsto_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {Γ₀ : Type.{u2}} [_inst_1 : LinearOrderedCommGroupWithZero.{u2} Γ₀] {l : Filter.{u1} α} {f : α -> Γ₀}, Iff (Filter.Tendsto.{u1, u2} α Γ₀ f l (nhds.{u2} Γ₀ (WithZeroTopology.topologicalSpace.{u2} Γ₀ _inst_1) (OfNat.ofNat.{u2} Γ₀ 0 (OfNat.mk.{u2} Γ₀ 0 (Zero.zero.{u2} Γ₀ (MulZeroClass.toHasZero.{u2} Γ₀ (MulZeroOneClass.toMulZeroClass.{u2} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u2} Γ₀ (GroupWithZero.toMonoidWithZero.{u2} Γ₀ (CommGroupWithZero.toGroupWithZero.{u2} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u2} Γ₀ _inst_1))))))))))) (forall (γ₀ : Γ₀), (Ne.{succ u2} Γ₀ γ₀ (OfNat.ofNat.{u2} Γ₀ 0 (OfNat.mk.{u2} Γ₀ 0 (Zero.zero.{u2} Γ₀ (MulZeroClass.toHasZero.{u2} Γ₀ (MulZeroOneClass.toMulZeroClass.{u2} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u2} Γ₀ (GroupWithZero.toMonoidWithZero.{u2} Γ₀ (CommGroupWithZero.toGroupWithZero.{u2} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u2} Γ₀ _inst_1)))))))))) -> (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} Γ₀ (Preorder.toHasLt.{u2} Γ₀ (PartialOrder.toPreorder.{u2} Γ₀ (OrderedCommMonoid.toPartialOrder.{u2} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u2} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u2} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u2} Γ₀ _inst_1)))))) (f x) γ₀) l))
-but is expected to have type
-  forall {α : Type.{u2}} {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {l : Filter.{u2} α} {f : α -> Γ₀}, Iff (Filter.Tendsto.{u2, u1} α Γ₀ f l (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))))) (forall (γ₀ : Γ₀), (Ne.{succ u1} Γ₀ γ₀ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) -> (Filter.Eventually.{u2} α (fun (x : α) => LT.lt.{u1} Γ₀ (Preorder.toLT.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))))) (f x) γ₀) l))
-Case conversion may be inaccurate. Consider using '#align with_zero_topology.tendsto_zero WithZeroTopology.tendsto_zeroₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ₀ «expr ≠ » 0) -/
 theorem tendsto_zero : Tendsto f l (𝓝 (0 : Γ₀)) ↔ ∀ (γ₀) (_ : γ₀ ≠ 0), ∀ᶠ x in l, f x < γ₀ := by
   simp [nhds_zero]
@@ -138,12 +102,6 @@ theorem tendsto_zero : Tendsto f l (𝓝 (0 : Γ₀)) ↔ ∀ (γ₀) (_ : γ₀
 -/
 
 
-/- warning: with_zero_topology.nhds_of_ne_zero -> WithZeroTopology.nhds_of_ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {γ : Γ₀}, (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) -> (Eq.{succ u1} (Filter.{u1} Γ₀) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) γ) (Pure.pure.{u1, u1} Filter.{u1} Filter.hasPure.{u1} Γ₀ γ))
-but is expected to have type
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {γ : Γ₀}, (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) -> (Eq.{succ u1} (Filter.{u1} Γ₀) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) γ) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} Γ₀ γ))
-Case conversion may be inaccurate. Consider using '#align with_zero_topology.nhds_of_ne_zero WithZeroTopology.nhds_of_ne_zeroₓ'. -/
 /-- The neighbourhood filter of a nonzero element consists of all sets containing that
 element. -/
 @[simp]
@@ -166,23 +124,11 @@ theorem singleton_mem_nhds_of_units (γ : Γ₀ˣ) : ({γ} : Set Γ₀) ∈ 𝓝
 #align with_zero_topology.singleton_mem_nhds_of_units WithZeroTopology.singleton_mem_nhds_of_units
 -/
 
-/- warning: with_zero_topology.singleton_mem_nhds_of_ne_zero -> WithZeroTopology.singleton_mem_nhds_of_ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {γ : Γ₀}, (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) -> (Membership.Mem.{u1, u1} (Set.{u1} Γ₀) (Filter.{u1} Γ₀) (Filter.hasMem.{u1} Γ₀) (Singleton.singleton.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.hasSingleton.{u1} Γ₀) γ) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) γ))
-but is expected to have type
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {γ : Γ₀}, (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) -> (Membership.mem.{u1, u1} (Set.{u1} Γ₀) (Filter.{u1} Γ₀) (instMembershipSetFilter.{u1} Γ₀) (Singleton.singleton.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.instSingletonSet.{u1} Γ₀) γ) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) γ))
-Case conversion may be inaccurate. Consider using '#align with_zero_topology.singleton_mem_nhds_of_ne_zero WithZeroTopology.singleton_mem_nhds_of_ne_zeroₓ'. -/
 /-- If `γ` is a nonzero element of a linearly ordered group with zero element adjoined, then `{γ}`
 is a neighbourhood of `γ`. -/
 theorem singleton_mem_nhds_of_ne_zero (h : γ ≠ 0) : ({γ} : Set Γ₀) ∈ 𝓝 (γ : Γ₀) := by simp [h]
 #align with_zero_topology.singleton_mem_nhds_of_ne_zero WithZeroTopology.singleton_mem_nhds_of_ne_zero
 
-/- warning: with_zero_topology.has_basis_nhds_of_ne_zero -> WithZeroTopology.hasBasis_nhds_of_ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {x : Γ₀}, (Ne.{succ u1} Γ₀ x (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) -> (Filter.HasBasis.{u1, 1} Γ₀ Unit (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) x) (fun (i : Unit) => True) (fun (i : Unit) => Singleton.singleton.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.hasSingleton.{u1} Γ₀) x))
-but is expected to have type
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {x : Γ₀}, (Ne.{succ u1} Γ₀ x (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) -> (Filter.HasBasis.{u1, 1} Γ₀ Unit (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) x) (fun (i : Unit) => True) (fun (i : Unit) => Singleton.singleton.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.instSingletonSet.{u1} Γ₀) x))
-Case conversion may be inaccurate. Consider using '#align with_zero_topology.has_basis_nhds_of_ne_zero WithZeroTopology.hasBasis_nhds_of_ne_zeroₓ'. -/
 theorem hasBasis_nhds_of_ne_zero {x : Γ₀} (h : x ≠ 0) :
     HasBasis (𝓝 x) (fun i : Unit => True) fun i => {x} := by rw [nhds_of_ne_zero h];
   exact has_basis_pure _
@@ -194,12 +140,6 @@ theorem hasBasis_nhds_units (γ : Γ₀ˣ) : HasBasis (𝓝 (γ : Γ₀)) (fun i
 #align with_zero_topology.has_basis_nhds_units WithZeroTopology.hasBasis_nhds_units
 -/
 
-/- warning: with_zero_topology.tendsto_of_ne_zero -> WithZeroTopology.tendsto_of_ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {Γ₀ : Type.{u2}} [_inst_1 : LinearOrderedCommGroupWithZero.{u2} Γ₀] {l : Filter.{u1} α} {f : α -> Γ₀} {γ : Γ₀}, (Ne.{succ u2} Γ₀ γ (OfNat.ofNat.{u2} Γ₀ 0 (OfNat.mk.{u2} Γ₀ 0 (Zero.zero.{u2} Γ₀ (MulZeroClass.toHasZero.{u2} Γ₀ (MulZeroOneClass.toMulZeroClass.{u2} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u2} Γ₀ (GroupWithZero.toMonoidWithZero.{u2} Γ₀ (CommGroupWithZero.toGroupWithZero.{u2} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u2} Γ₀ _inst_1)))))))))) -> (Iff (Filter.Tendsto.{u1, u2} α Γ₀ f l (nhds.{u2} Γ₀ (WithZeroTopology.topologicalSpace.{u2} Γ₀ _inst_1) γ)) (Filter.Eventually.{u1} α (fun (x : α) => Eq.{succ u2} Γ₀ (f x) γ) l))
-but is expected to have type
-  forall {α : Type.{u1}} {Γ₀ : Type.{u2}} [_inst_1 : LinearOrderedCommGroupWithZero.{u2} Γ₀] {l : Filter.{u1} α} {f : α -> Γ₀} {γ : Γ₀}, (Ne.{succ u2} Γ₀ γ (OfNat.ofNat.{u2} Γ₀ 0 (Zero.toOfNat0.{u2} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u2} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u2} Γ₀ _inst_1))))) -> (Iff (Filter.Tendsto.{u1, u2} α Γ₀ f l (nhds.{u2} Γ₀ (WithZeroTopology.topologicalSpace.{u2} Γ₀ _inst_1) γ)) (Filter.Eventually.{u1} α (fun (x : α) => Eq.{succ u2} Γ₀ (f x) γ) l))
-Case conversion may be inaccurate. Consider using '#align with_zero_topology.tendsto_of_ne_zero WithZeroTopology.tendsto_of_ne_zeroₓ'. -/
 theorem tendsto_of_ne_zero {γ : Γ₀} (h : γ ≠ 0) : Tendsto f l (𝓝 γ) ↔ ∀ᶠ x in l, f x = γ := by
   rw [nhds_of_ne_zero h, tendsto_pure]
 #align with_zero_topology.tendsto_of_ne_zero WithZeroTopology.tendsto_of_ne_zero
@@ -210,12 +150,6 @@ theorem tendsto_units {γ₀ : Γ₀ˣ} : Tendsto f l (𝓝 (γ₀ : Γ₀)) ↔
 #align with_zero_topology.tendsto_units WithZeroTopology.tendsto_units
 -/
 
-/- warning: with_zero_topology.Iio_mem_nhds -> WithZeroTopology.Iio_mem_nhds is a dubious translation:
-lean 3 declaration is
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {γ₁ : Γ₀} {γ₂ : Γ₀}, (LT.lt.{u1} Γ₀ (Preorder.toHasLt.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))))) γ₁ γ₂) -> (Membership.Mem.{u1, u1} (Set.{u1} Γ₀) (Filter.{u1} Γ₀) (Filter.hasMem.{u1} Γ₀) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ₂) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) γ₁))
-but is expected to have type
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {γ₁ : Γ₀} {γ₂ : Γ₀}, (LT.lt.{u1} Γ₀ (Preorder.toLT.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))))) γ₁ γ₂) -> (Membership.mem.{u1, u1} (Set.{u1} Γ₀) (Filter.{u1} Γ₀) (instMembershipSetFilter.{u1} Γ₀) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ₂) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) γ₁))
-Case conversion may be inaccurate. Consider using '#align with_zero_topology.Iio_mem_nhds WithZeroTopology.Iio_mem_nhdsₓ'. -/
 theorem Iio_mem_nhds (h : γ₁ < γ₂) : Iio γ₂ ∈ 𝓝 γ₁ := by
   rcases eq_or_ne γ₁ 0 with (rfl | h₀) <;> simp [*, h.ne', Iio_mem_nhds_zero]
 #align with_zero_topology.Iio_mem_nhds WithZeroTopology.Iio_mem_nhds
@@ -225,12 +159,6 @@ theorem Iio_mem_nhds (h : γ₁ < γ₂) : Iio γ₂ ∈ 𝓝 γ₁ := by
 -/
 
 
-/- warning: with_zero_topology.is_open_iff -> WithZeroTopology.isOpen_iff is a dubious translation:
-lean 3 declaration is
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {s : Set.{u1} Γ₀}, Iff (IsOpen.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) s) (Or (Not (Membership.Mem.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.hasMem.{u1} Γ₀) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))))))) s)) (Exists.{succ u1} Γ₀ (fun (γ : Γ₀) => Exists.{0} (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) => HasSubset.Subset.{u1} (Set.{u1} Γ₀) (Set.hasSubset.{u1} Γ₀) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ) s))))
-but is expected to have type
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {s : Set.{u1} Γ₀}, Iff (IsOpen.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) s) (Or (Not (Membership.mem.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.instMembershipSet.{u1} Γ₀) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))) s)) (Exists.{succ u1} Γ₀ (fun (γ : Γ₀) => And (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (HasSubset.Subset.{u1} (Set.{u1} Γ₀) (Set.instHasSubsetSet.{u1} Γ₀) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ) s))))
-Case conversion may be inaccurate. Consider using '#align with_zero_topology.is_open_iff WithZeroTopology.isOpen_iffₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ : _)(_ : γ ≠ 0), Iio γ ⊆ s :=
   by
@@ -239,12 +167,6 @@ theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ
     has_basis_nhds_zero.mem_iff]
 #align with_zero_topology.is_open_iff WithZeroTopology.isOpen_iff
 
-/- warning: with_zero_topology.is_closed_iff -> WithZeroTopology.isClosed_iff is a dubious translation:
-lean 3 declaration is
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {s : Set.{u1} Γ₀}, Iff (IsClosed.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) s) (Or (Membership.Mem.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.hasMem.{u1} Γ₀) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))))))) s) (Exists.{succ u1} Γ₀ (fun (γ : Γ₀) => Exists.{0} (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) => HasSubset.Subset.{u1} (Set.{u1} Γ₀) (Set.hasSubset.{u1} Γ₀) s (Set.Ici.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ)))))
-but is expected to have type
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {s : Set.{u1} Γ₀}, Iff (IsClosed.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) s) (Or (Membership.mem.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.instMembershipSet.{u1} Γ₀) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))) s) (Exists.{succ u1} Γ₀ (fun (γ : Γ₀) => And (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (HasSubset.Subset.{u1} (Set.{u1} Γ₀) (Set.instHasSubsetSet.{u1} Γ₀) s (Set.Ici.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ)))))
-Case conversion may be inaccurate. Consider using '#align with_zero_topology.is_closed_iff WithZeroTopology.isClosed_iffₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem isClosed_iff {s : Set Γ₀} : IsClosed s ↔ (0 : Γ₀) ∈ s ∨ ∃ (γ : _)(_ : γ ≠ 0), s ⊆ Ici γ :=
   by

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

@@ -184,9 +184,7 @@ but is expected to have type
   forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {x : Γ₀}, (Ne.{succ u1} Γ₀ x (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) -> (Filter.HasBasis.{u1, 1} Γ₀ Unit (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) x) (fun (i : Unit) => True) (fun (i : Unit) => Singleton.singleton.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.instSingletonSet.{u1} Γ₀) x))
 Case conversion may be inaccurate. Consider using '#align with_zero_topology.has_basis_nhds_of_ne_zero WithZeroTopology.hasBasis_nhds_of_ne_zeroₓ'. -/
 theorem hasBasis_nhds_of_ne_zero {x : Γ₀} (h : x ≠ 0) :
-    HasBasis (𝓝 x) (fun i : Unit => True) fun i => {x} :=
-  by
-  rw [nhds_of_ne_zero h]
+    HasBasis (𝓝 x) (fun i : Unit => True) fun i => {x} := by rw [nhds_of_ne_zero h];
   exact has_basis_pure _
 #align with_zero_topology.has_basis_nhds_of_ne_zero WithZeroTopology.hasBasis_nhds_of_ne_zero
 
@@ -333,9 +331,7 @@ protected theorem continuousMul : ContinuousMul Γ₀ :=
 attribute [scoped instance] WithZeroTopology.continuousMul
 
 protected theorem hasContinuousInv₀ : HasContinuousInv₀ Γ₀ :=
-  ⟨fun γ h => by
-    rw [ContinuousAt, nhds_of_ne_zero h]
-    exact pure_le_nhds γ⁻¹⟩
+  ⟨fun γ h => by rw [ContinuousAt, nhds_of_ne_zero h]; exact pure_le_nhds γ⁻¹⟩
 #align with_zero_topology.has_continuous_inv₀ WithZeroTopology.hasContinuousInv₀
 
 attribute [scoped instance] WithZeroTopology.hasContinuousInv₀

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

@@ -310,7 +310,7 @@ protected theorem continuousMul : ContinuousMul Γ₀ :=
     wlog hle : x ≤ y generalizing x y
     · have := tendsto.comp (this y x (le_of_not_le hle)) (continuous_swap.tendsto (x, y))
       simpa only [mul_comm, Function.comp, Prod.swap]
-    rcases eq_or_ne x 0 with (rfl | hx) <;> [rcases eq_or_ne y 0 with (rfl | hy), skip]
+    rcases eq_or_ne x 0 with (rfl | hx) <;> [rcases eq_or_ne y 0 with (rfl | hy);skip]
     · rw [ContinuousAt, MulZeroClass.zero_mul]
       refine'
         ((has_basis_nhds_zero.prod_nhds has_basis_nhds_zero).tendsto_iffₓ has_basis_nhds_zero).2

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

@@ -124,7 +124,7 @@ theorem nhds_zero_of_units (γ : Γ₀ˣ) : Iio ↑γ ∈ 𝓝 (0 : Γ₀) :=
 
 /- warning: with_zero_topology.tendsto_zero -> WithZeroTopology.tendsto_zero is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {Γ₀ : Type.{u2}} [_inst_1 : LinearOrderedCommGroupWithZero.{u2} Γ₀] {l : Filter.{u1} α} {f : α -> Γ₀}, Iff (Filter.Tendsto.{u1, u2} α Γ₀ f l (nhds.{u2} Γ₀ (WithZeroTopology.topologicalSpace.{u2} Γ₀ _inst_1) (OfNat.ofNat.{u2} Γ₀ 0 (OfNat.mk.{u2} Γ₀ 0 (Zero.zero.{u2} Γ₀ (MulZeroClass.toHasZero.{u2} Γ₀ (MulZeroOneClass.toMulZeroClass.{u2} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u2} Γ₀ (GroupWithZero.toMonoidWithZero.{u2} Γ₀ (CommGroupWithZero.toGroupWithZero.{u2} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u2} Γ₀ _inst_1))))))))))) (forall (γ₀ : Γ₀), (Ne.{succ u2} Γ₀ γ₀ (OfNat.ofNat.{u2} Γ₀ 0 (OfNat.mk.{u2} Γ₀ 0 (Zero.zero.{u2} Γ₀ (MulZeroClass.toHasZero.{u2} Γ₀ (MulZeroOneClass.toMulZeroClass.{u2} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u2} Γ₀ (GroupWithZero.toMonoidWithZero.{u2} Γ₀ (CommGroupWithZero.toGroupWithZero.{u2} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u2} Γ₀ _inst_1)))))))))) -> (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} Γ₀ (Preorder.toLT.{u2} Γ₀ (PartialOrder.toPreorder.{u2} Γ₀ (OrderedCommMonoid.toPartialOrder.{u2} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u2} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u2} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u2} Γ₀ _inst_1)))))) (f x) γ₀) l))
+  forall {α : Type.{u1}} {Γ₀ : Type.{u2}} [_inst_1 : LinearOrderedCommGroupWithZero.{u2} Γ₀] {l : Filter.{u1} α} {f : α -> Γ₀}, Iff (Filter.Tendsto.{u1, u2} α Γ₀ f l (nhds.{u2} Γ₀ (WithZeroTopology.topologicalSpace.{u2} Γ₀ _inst_1) (OfNat.ofNat.{u2} Γ₀ 0 (OfNat.mk.{u2} Γ₀ 0 (Zero.zero.{u2} Γ₀ (MulZeroClass.toHasZero.{u2} Γ₀ (MulZeroOneClass.toMulZeroClass.{u2} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u2} Γ₀ (GroupWithZero.toMonoidWithZero.{u2} Γ₀ (CommGroupWithZero.toGroupWithZero.{u2} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u2} Γ₀ _inst_1))))))))))) (forall (γ₀ : Γ₀), (Ne.{succ u2} Γ₀ γ₀ (OfNat.ofNat.{u2} Γ₀ 0 (OfNat.mk.{u2} Γ₀ 0 (Zero.zero.{u2} Γ₀ (MulZeroClass.toHasZero.{u2} Γ₀ (MulZeroOneClass.toMulZeroClass.{u2} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u2} Γ₀ (GroupWithZero.toMonoidWithZero.{u2} Γ₀ (CommGroupWithZero.toGroupWithZero.{u2} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u2} Γ₀ _inst_1)))))))))) -> (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} Γ₀ (Preorder.toHasLt.{u2} Γ₀ (PartialOrder.toPreorder.{u2} Γ₀ (OrderedCommMonoid.toPartialOrder.{u2} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u2} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u2} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u2} Γ₀ _inst_1)))))) (f x) γ₀) l))
 but is expected to have type
   forall {α : Type.{u2}} {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {l : Filter.{u2} α} {f : α -> Γ₀}, Iff (Filter.Tendsto.{u2, u1} α Γ₀ f l (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))))) (forall (γ₀ : Γ₀), (Ne.{succ u1} Γ₀ γ₀ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) -> (Filter.Eventually.{u2} α (fun (x : α) => LT.lt.{u1} Γ₀ (Preorder.toLT.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))))) (f x) γ₀) l))
 Case conversion may be inaccurate. Consider using '#align with_zero_topology.tendsto_zero WithZeroTopology.tendsto_zeroₓ'. -/
@@ -212,11 +212,15 @@ theorem tendsto_units {γ₀ : Γ₀ˣ} : Tendsto f l (𝓝 (γ₀ : Γ₀)) ↔
 #align with_zero_topology.tendsto_units WithZeroTopology.tendsto_units
 -/
 
-#print WithZeroTopology.Iio_mem_nhds /-
+/- warning: with_zero_topology.Iio_mem_nhds -> WithZeroTopology.Iio_mem_nhds is a dubious translation:
+lean 3 declaration is
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {γ₁ : Γ₀} {γ₂ : Γ₀}, (LT.lt.{u1} Γ₀ (Preorder.toHasLt.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))))) γ₁ γ₂) -> (Membership.Mem.{u1, u1} (Set.{u1} Γ₀) (Filter.{u1} Γ₀) (Filter.hasMem.{u1} Γ₀) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ₂) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) γ₁))
+but is expected to have type
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {γ₁ : Γ₀} {γ₂ : Γ₀}, (LT.lt.{u1} Γ₀ (Preorder.toLT.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))))) γ₁ γ₂) -> (Membership.mem.{u1, u1} (Set.{u1} Γ₀) (Filter.{u1} Γ₀) (instMembershipSetFilter.{u1} Γ₀) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ₂) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) γ₁))
+Case conversion may be inaccurate. Consider using '#align with_zero_topology.Iio_mem_nhds WithZeroTopology.Iio_mem_nhdsₓ'. -/
 theorem Iio_mem_nhds (h : γ₁ < γ₂) : Iio γ₂ ∈ 𝓝 γ₁ := by
   rcases eq_or_ne γ₁ 0 with (rfl | h₀) <;> simp [*, h.ne', Iio_mem_nhds_zero]
 #align with_zero_topology.Iio_mem_nhds WithZeroTopology.Iio_mem_nhds
--/
 
 /-!
 ### Open/closed sets

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

@@ -61,13 +61,13 @@ attribute [scoped instance] WithZeroTopology.topologicalSpace
 
 /- warning: with_zero_topology.nhds_eq_update -> WithZeroTopology.nhds_eq_update is a dubious translation:
 lean 3 declaration is
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Eq.{succ u1} (Γ₀ -> (Filter.{u1} Γ₀)) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1)) (Function.update.{succ u1, succ u1} Γ₀ (fun (a : Γ₀) => Filter.{u1} Γ₀) (fun (a : Γ₀) (b : Γ₀) => Eq.decidable.{u1} Γ₀ (LinearOrderedCommMonoid.toLinearOrder.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))) a b) (Pure.pure.{u1, u1} (fun {Γ₀ : Type.{u1}} => Filter.{u1} Γ₀) Filter.hasPure.{u1} Γ₀) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))))))) (infᵢ.{u1, succ u1} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.completeLattice.{u1} Γ₀))) Γ₀ (fun (γ : Γ₀) => infᵢ.{u1, 0} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.completeLattice.{u1} Γ₀))) (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) => Filter.principal.{u1} Γ₀ (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ)))))
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Eq.{succ u1} (Γ₀ -> (Filter.{u1} Γ₀)) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1)) (Function.update.{succ u1, succ u1} Γ₀ (fun (a : Γ₀) => Filter.{u1} Γ₀) (fun (a : Γ₀) (b : Γ₀) => Eq.decidable.{u1} Γ₀ (LinearOrderedCommMonoid.toLinearOrder.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))) a b) (Pure.pure.{u1, u1} (fun {Γ₀ : Type.{u1}} => Filter.{u1} Γ₀) Filter.hasPure.{u1} Γ₀) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))))))) (iInf.{u1, succ u1} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.completeLattice.{u1} Γ₀))) Γ₀ (fun (γ : Γ₀) => iInf.{u1, 0} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.completeLattice.{u1} Γ₀))) (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) => Filter.principal.{u1} Γ₀ (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ)))))
 but is expected to have type
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Eq.{succ u1} (Γ₀ -> (Filter.{u1} Γ₀)) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1)) (Function.update.{succ u1, succ u1} Γ₀ (fun (a : Γ₀) => Filter.{u1} Γ₀) (fun (a : Γ₀) (b : Γ₀) => instDecidableEq.{u1} Γ₀ (LinearOrderedCommMonoid.toLinearOrder.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))) a b) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} Γ₀) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))) (infᵢ.{u1, succ u1} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.instCompleteLatticeFilter.{u1} Γ₀))) Γ₀ (fun (γ : Γ₀) => infᵢ.{u1, 0} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.instCompleteLatticeFilter.{u1} Γ₀))) (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) => Filter.principal.{u1} Γ₀ (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ)))))
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Eq.{succ u1} (Γ₀ -> (Filter.{u1} Γ₀)) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1)) (Function.update.{succ u1, succ u1} Γ₀ (fun (a : Γ₀) => Filter.{u1} Γ₀) (fun (a : Γ₀) (b : Γ₀) => instDecidableEq.{u1} Γ₀ (LinearOrderedCommMonoid.toLinearOrder.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))) a b) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} Γ₀) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))) (iInf.{u1, succ u1} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.instCompleteLatticeFilter.{u1} Γ₀))) Γ₀ (fun (γ : Γ₀) => iInf.{u1, 0} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.instCompleteLatticeFilter.{u1} Γ₀))) (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) => Filter.principal.{u1} Γ₀ (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ)))))
 Case conversion may be inaccurate. Consider using '#align with_zero_topology.nhds_eq_update WithZeroTopology.nhds_eq_updateₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ)) :=
-  funext <| nhds_mkOfNhds_single <| le_infᵢ₂ fun γ h₀ => le_principal_iff.2 <| zero_lt_iff.2 h₀
+  funext <| nhds_mkOfNhds_single <| le_iInf₂ fun γ h₀ => le_principal_iff.2 <| zero_lt_iff.2 h₀
 #align with_zero_topology.nhds_eq_update WithZeroTopology.nhds_eq_update
 
 /-!
@@ -77,9 +77,9 @@ theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (
 
 /- warning: with_zero_topology.nhds_zero -> WithZeroTopology.nhds_zero is a dubious translation:
 lean 3 declaration is
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Eq.{succ u1} (Filter.{u1} Γ₀) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (infᵢ.{u1, succ u1} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.completeLattice.{u1} Γ₀))) Γ₀ (fun (γ : Γ₀) => infᵢ.{u1, 0} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.completeLattice.{u1} Γ₀))) (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) => Filter.principal.{u1} Γ₀ (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ))))
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Eq.{succ u1} (Filter.{u1} Γ₀) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (iInf.{u1, succ u1} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.completeLattice.{u1} Γ₀))) Γ₀ (fun (γ : Γ₀) => iInf.{u1, 0} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.completeLattice.{u1} Γ₀))) (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) => Filter.principal.{u1} Γ₀ (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ))))
 but is expected to have type
-  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Eq.{succ u1} (Filter.{u1} Γ₀) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (infᵢ.{u1, succ u1} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.instCompleteLatticeFilter.{u1} Γ₀))) Γ₀ (fun (γ : Γ₀) => infᵢ.{u1, 0} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.instCompleteLatticeFilter.{u1} Γ₀))) (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) => Filter.principal.{u1} Γ₀ (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ))))
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Eq.{succ u1} (Filter.{u1} Γ₀) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (iInf.{u1, succ u1} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.instCompleteLatticeFilter.{u1} Γ₀))) Γ₀ (fun (γ : Γ₀) => iInf.{u1, 0} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.instCompleteLatticeFilter.{u1} Γ₀))) (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) => Filter.principal.{u1} Γ₀ (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ))))
 Case conversion may be inaccurate. Consider using '#align with_zero_topology.nhds_zero WithZeroTopology.nhds_zeroₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem nhds_zero : 𝓝 (0 : Γ₀) = ⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ) := by rw [nhds_eq_update, update_same]

mathlib commit https://github.com/leanprover-community/mathlib/commit/1f4705ccdfe1e557fc54a0ce081a05e33d2e6240

@@ -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.with_zero_topology
-! leanprover-community/mathlib commit 3e0c4d76b6ebe9dfafb67d16f7286d2731ed6064
+! leanprover-community/mathlib commit 932872382355f00112641d305ba0619305dc8642
 ! 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.Order.Field
 /-!
 # The topology on linearly ordered commutative groups with zero
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 Let `Γ₀` be a linearly ordered commutative group to which we have adjoined a zero element.
 Then `Γ₀` may naturally be endowed with a topology that turns `Γ₀` into a topological monoid.
 Neighborhoods of zero are sets containing `{γ | γ < γ₀}` for some invertible element `γ₀`

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

@@ -46,14 +46,22 @@ variable {α Γ₀ : Type _} [LinearOrderedCommGroupWithZero Γ₀] {γ γ₁ γ
   {f : α → Γ₀}
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+#print WithZeroTopology.topologicalSpace /-
 /-- The topology on a linearly ordered commutative group with a zero element adjoined.
 A subset U is open if 0 ∉ U or if there is an invertible element γ₀ such that {γ | γ < γ₀} ⊆ U. -/
 protected def topologicalSpace : TopologicalSpace Γ₀ :=
   TopologicalSpace.mkOfNhds <| update pure 0 <| ⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ)
 #align with_zero_topology.topological_space WithZeroTopology.topologicalSpace
+-/
 
 attribute [scoped instance] WithZeroTopology.topologicalSpace
 
+/- warning: with_zero_topology.nhds_eq_update -> WithZeroTopology.nhds_eq_update is a dubious translation:
+lean 3 declaration is
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Eq.{succ u1} (Γ₀ -> (Filter.{u1} Γ₀)) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1)) (Function.update.{succ u1, succ u1} Γ₀ (fun (a : Γ₀) => Filter.{u1} Γ₀) (fun (a : Γ₀) (b : Γ₀) => Eq.decidable.{u1} Γ₀ (LinearOrderedCommMonoid.toLinearOrder.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))) a b) (Pure.pure.{u1, u1} (fun {Γ₀ : Type.{u1}} => Filter.{u1} Γ₀) Filter.hasPure.{u1} Γ₀) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))))))) (infᵢ.{u1, succ u1} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.completeLattice.{u1} Γ₀))) Γ₀ (fun (γ : Γ₀) => infᵢ.{u1, 0} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.completeLattice.{u1} Γ₀))) (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) => Filter.principal.{u1} Γ₀ (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ)))))
+but is expected to have type
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Eq.{succ u1} (Γ₀ -> (Filter.{u1} Γ₀)) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1)) (Function.update.{succ u1, succ u1} Γ₀ (fun (a : Γ₀) => Filter.{u1} Γ₀) (fun (a : Γ₀) (b : Γ₀) => instDecidableEq.{u1} Γ₀ (LinearOrderedCommMonoid.toLinearOrder.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))) a b) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} Γ₀) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))) (infᵢ.{u1, succ u1} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.instCompleteLatticeFilter.{u1} Γ₀))) Γ₀ (fun (γ : Γ₀) => infᵢ.{u1, 0} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.instCompleteLatticeFilter.{u1} Γ₀))) (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) => Filter.principal.{u1} Γ₀ (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ)))))
+Case conversion may be inaccurate. Consider using '#align with_zero_topology.nhds_eq_update WithZeroTopology.nhds_eq_updateₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ)) :=
   funext <| nhds_mkOfNhds_single <| le_infᵢ₂ fun γ h₀ => le_principal_iff.2 <| zero_lt_iff.2 h₀
@@ -64,10 +72,22 @@ theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (
 -/
 
 
+/- warning: with_zero_topology.nhds_zero -> WithZeroTopology.nhds_zero is a dubious translation:
+lean 3 declaration is
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Eq.{succ u1} (Filter.{u1} Γ₀) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (infᵢ.{u1, succ u1} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.completeLattice.{u1} Γ₀))) Γ₀ (fun (γ : Γ₀) => infᵢ.{u1, 0} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.completeLattice.{u1} Γ₀))) (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) => Filter.principal.{u1} Γ₀ (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ))))
+but is expected to have type
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Eq.{succ u1} (Filter.{u1} Γ₀) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (infᵢ.{u1, succ u1} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.instCompleteLatticeFilter.{u1} Γ₀))) Γ₀ (fun (γ : Γ₀) => infᵢ.{u1, 0} (Filter.{u1} Γ₀) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} Γ₀) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} Γ₀) (Filter.instCompleteLatticeFilter.{u1} Γ₀))) (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) => Filter.principal.{u1} Γ₀ (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ))))
+Case conversion may be inaccurate. Consider using '#align with_zero_topology.nhds_zero WithZeroTopology.nhds_zeroₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem nhds_zero : 𝓝 (0 : Γ₀) = ⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ) := by rw [nhds_eq_update, update_same]
 #align with_zero_topology.nhds_zero WithZeroTopology.nhds_zero
 
+/- warning: with_zero_topology.has_basis_nhds_zero -> WithZeroTopology.hasBasis_nhds_zero is a dubious translation:
+lean 3 declaration is
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Filter.HasBasis.{u1, succ u1} Γ₀ Γ₀ (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (fun (γ : Γ₀) => Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))))
+but is expected to have type
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀], Filter.HasBasis.{u1, succ u1} Γ₀ Γ₀ (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (fun (γ : Γ₀) => Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))))
+Case conversion may be inaccurate. Consider using '#align with_zero_topology.has_basis_nhds_zero WithZeroTopology.hasBasis_nhds_zeroₓ'. -/
 /-- In a linearly ordered group with zero element adjoined, `U` is a neighbourhood of `0` if and
 only if there exists a nonzero element `γ₀` such that `Iio γ₀ ⊆ U`. -/
 theorem hasBasis_nhds_zero : (𝓝 (0 : Γ₀)).HasBasis (fun γ : Γ₀ => γ ≠ 0) Iio :=
@@ -77,16 +97,34 @@ theorem hasBasis_nhds_zero : (𝓝 (0 : Γ₀)).HasBasis (fun γ : Γ₀ => γ 
   exact directedOn_iff_directed.2 (directed_of_inf fun a b hab => Iio_subset_Iio hab)
 #align with_zero_topology.has_basis_nhds_zero WithZeroTopology.hasBasis_nhds_zero
 
+/- warning: with_zero_topology.Iio_mem_nhds_zero -> WithZeroTopology.Iio_mem_nhds_zero is a dubious translation:
+lean 3 declaration is
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {γ : Γ₀}, (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) -> (Membership.Mem.{u1, u1} (Set.{u1} Γ₀) (Filter.{u1} Γ₀) (Filter.hasMem.{u1} Γ₀) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))))
+but is expected to have type
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {γ : Γ₀}, (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) -> (Membership.mem.{u1, u1} (Set.{u1} Γ₀) (Filter.{u1} Γ₀) (instMembershipSetFilter.{u1} Γ₀) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))))
+Case conversion may be inaccurate. Consider using '#align with_zero_topology.Iio_mem_nhds_zero WithZeroTopology.Iio_mem_nhds_zeroₓ'. -/
 theorem Iio_mem_nhds_zero (hγ : γ ≠ 0) : Iio γ ∈ 𝓝 (0 : Γ₀) :=
   hasBasis_nhds_zero.mem_of_mem hγ
 #align with_zero_topology.Iio_mem_nhds_zero WithZeroTopology.Iio_mem_nhds_zero
 
+/- warning: with_zero_topology.nhds_zero_of_units -> WithZeroTopology.nhds_zero_of_units is a dubious translation:
+lean 3 declaration is
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] (γ : Units.{u1} Γ₀ (MonoidWithZero.toMonoid.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))), Membership.Mem.{u1, u1} (Set.{u1} Γ₀) (Filter.{u1} Γ₀) (Filter.hasMem.{u1} Γ₀) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} Γ₀ (MonoidWithZero.toMonoid.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))) Γ₀ (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} Γ₀ (MonoidWithZero.toMonoid.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))) Γ₀ (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} Γ₀ (MonoidWithZero.toMonoid.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))) Γ₀ (coeBase.{succ u1, succ u1} (Units.{u1} Γ₀ (MonoidWithZero.toMonoid.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))) Γ₀ (Units.hasCoe.{u1} Γ₀ (MonoidWithZero.toMonoid.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))) γ)) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))))))))
+but is expected to have type
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] (γ : Units.{u1} Γ₀ (MonoidWithZero.toMonoid.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))), Membership.mem.{u1, u1} (Set.{u1} Γ₀) (Filter.{u1} Γ₀) (instMembershipSetFilter.{u1} Γ₀) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (Units.val.{u1} Γ₀ (MonoidWithZero.toMonoid.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))) γ)) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))))
+Case conversion may be inaccurate. Consider using '#align with_zero_topology.nhds_zero_of_units WithZeroTopology.nhds_zero_of_unitsₓ'. -/
 /-- If `γ` is an invertible element of a linearly ordered group with zero element adjoined, then
 `Iio (γ : Γ₀)` is a neighbourhood of `0`. -/
 theorem nhds_zero_of_units (γ : Γ₀ˣ) : Iio ↑γ ∈ 𝓝 (0 : Γ₀) :=
   Iio_mem_nhds_zero γ.NeZero
 #align with_zero_topology.nhds_zero_of_units WithZeroTopology.nhds_zero_of_units
 
+/- warning: with_zero_topology.tendsto_zero -> WithZeroTopology.tendsto_zero is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {Γ₀ : Type.{u2}} [_inst_1 : LinearOrderedCommGroupWithZero.{u2} Γ₀] {l : Filter.{u1} α} {f : α -> Γ₀}, Iff (Filter.Tendsto.{u1, u2} α Γ₀ f l (nhds.{u2} Γ₀ (WithZeroTopology.topologicalSpace.{u2} Γ₀ _inst_1) (OfNat.ofNat.{u2} Γ₀ 0 (OfNat.mk.{u2} Γ₀ 0 (Zero.zero.{u2} Γ₀ (MulZeroClass.toHasZero.{u2} Γ₀ (MulZeroOneClass.toMulZeroClass.{u2} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u2} Γ₀ (GroupWithZero.toMonoidWithZero.{u2} Γ₀ (CommGroupWithZero.toGroupWithZero.{u2} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u2} Γ₀ _inst_1))))))))))) (forall (γ₀ : Γ₀), (Ne.{succ u2} Γ₀ γ₀ (OfNat.ofNat.{u2} Γ₀ 0 (OfNat.mk.{u2} Γ₀ 0 (Zero.zero.{u2} Γ₀ (MulZeroClass.toHasZero.{u2} Γ₀ (MulZeroOneClass.toMulZeroClass.{u2} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u2} Γ₀ (GroupWithZero.toMonoidWithZero.{u2} Γ₀ (CommGroupWithZero.toGroupWithZero.{u2} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u2} Γ₀ _inst_1)))))))))) -> (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} Γ₀ (Preorder.toLT.{u2} Γ₀ (PartialOrder.toPreorder.{u2} Γ₀ (OrderedCommMonoid.toPartialOrder.{u2} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u2} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u2} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u2} Γ₀ _inst_1)))))) (f x) γ₀) l))
+but is expected to have type
+  forall {α : Type.{u2}} {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {l : Filter.{u2} α} {f : α -> Γ₀}, Iff (Filter.Tendsto.{u2, u1} α Γ₀ f l (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))))) (forall (γ₀ : Γ₀), (Ne.{succ u1} Γ₀ γ₀ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) -> (Filter.Eventually.{u2} α (fun (x : α) => LT.lt.{u1} Γ₀ (Preorder.toLT.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))))) (f x) γ₀) l))
+Case conversion may be inaccurate. Consider using '#align with_zero_topology.tendsto_zero WithZeroTopology.tendsto_zeroₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ₀ «expr ≠ » 0) -/
 theorem tendsto_zero : Tendsto f l (𝓝 (0 : Γ₀)) ↔ ∀ (γ₀) (_ : γ₀ ≠ 0), ∀ᶠ x in l, f x < γ₀ := by
   simp [nhds_zero]
@@ -97,6 +135,12 @@ theorem tendsto_zero : Tendsto f l (𝓝 (0 : Γ₀)) ↔ ∀ (γ₀) (_ : γ₀
 -/
 
 
+/- warning: with_zero_topology.nhds_of_ne_zero -> WithZeroTopology.nhds_of_ne_zero is a dubious translation:
+lean 3 declaration is
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {γ : Γ₀}, (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) -> (Eq.{succ u1} (Filter.{u1} Γ₀) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) γ) (Pure.pure.{u1, u1} Filter.{u1} Filter.hasPure.{u1} Γ₀ γ))
+but is expected to have type
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {γ : Γ₀}, (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) -> (Eq.{succ u1} (Filter.{u1} Γ₀) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) γ) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} Γ₀ γ))
+Case conversion may be inaccurate. Consider using '#align with_zero_topology.nhds_of_ne_zero WithZeroTopology.nhds_of_ne_zeroₓ'. -/
 /-- The neighbourhood filter of a nonzero element consists of all sets containing that
 element. -/
 @[simp]
@@ -104,22 +148,38 @@ theorem nhds_of_ne_zero {γ : Γ₀} (h₀ : γ ≠ 0) : 𝓝 γ = pure γ := by
   rw [nhds_eq_update, update_noteq h₀]
 #align with_zero_topology.nhds_of_ne_zero WithZeroTopology.nhds_of_ne_zero
 
+#print WithZeroTopology.nhds_coe_units /-
 /-- The neighbourhood filter of an invertible element consists of all sets containing that
 element. -/
 theorem nhds_coe_units (γ : Γ₀ˣ) : 𝓝 (γ : Γ₀) = pure (γ : Γ₀) :=
   nhds_of_ne_zero γ.NeZero
 #align with_zero_topology.nhds_coe_units WithZeroTopology.nhds_coe_units
+-/
 
+#print WithZeroTopology.singleton_mem_nhds_of_units /-
 /-- If `γ` is an invertible element of a linearly ordered group with zero element adjoined, then
 `{γ}` is a neighbourhood of `γ`. -/
 theorem singleton_mem_nhds_of_units (γ : Γ₀ˣ) : ({γ} : Set Γ₀) ∈ 𝓝 (γ : Γ₀) := by simp
 #align with_zero_topology.singleton_mem_nhds_of_units WithZeroTopology.singleton_mem_nhds_of_units
+-/
 
+/- warning: with_zero_topology.singleton_mem_nhds_of_ne_zero -> WithZeroTopology.singleton_mem_nhds_of_ne_zero is a dubious translation:
+lean 3 declaration is
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {γ : Γ₀}, (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) -> (Membership.Mem.{u1, u1} (Set.{u1} Γ₀) (Filter.{u1} Γ₀) (Filter.hasMem.{u1} Γ₀) (Singleton.singleton.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.hasSingleton.{u1} Γ₀) γ) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) γ))
+but is expected to have type
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {γ : Γ₀}, (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) -> (Membership.mem.{u1, u1} (Set.{u1} Γ₀) (Filter.{u1} Γ₀) (instMembershipSetFilter.{u1} Γ₀) (Singleton.singleton.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.instSingletonSet.{u1} Γ₀) γ) (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) γ))
+Case conversion may be inaccurate. Consider using '#align with_zero_topology.singleton_mem_nhds_of_ne_zero WithZeroTopology.singleton_mem_nhds_of_ne_zeroₓ'. -/
 /-- If `γ` is a nonzero element of a linearly ordered group with zero element adjoined, then `{γ}`
 is a neighbourhood of `γ`. -/
 theorem singleton_mem_nhds_of_ne_zero (h : γ ≠ 0) : ({γ} : Set Γ₀) ∈ 𝓝 (γ : Γ₀) := by simp [h]
 #align with_zero_topology.singleton_mem_nhds_of_ne_zero WithZeroTopology.singleton_mem_nhds_of_ne_zero
 
+/- warning: with_zero_topology.has_basis_nhds_of_ne_zero -> WithZeroTopology.hasBasis_nhds_of_ne_zero is a dubious translation:
+lean 3 declaration is
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {x : Γ₀}, (Ne.{succ u1} Γ₀ x (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) -> (Filter.HasBasis.{u1, 1} Γ₀ Unit (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) x) (fun (i : Unit) => True) (fun (i : Unit) => Singleton.singleton.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.hasSingleton.{u1} Γ₀) x))
+but is expected to have type
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {x : Γ₀}, (Ne.{succ u1} Γ₀ x (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) -> (Filter.HasBasis.{u1, 1} Γ₀ Unit (nhds.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) x) (fun (i : Unit) => True) (fun (i : Unit) => Singleton.singleton.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.instSingletonSet.{u1} Γ₀) x))
+Case conversion may be inaccurate. Consider using '#align with_zero_topology.has_basis_nhds_of_ne_zero WithZeroTopology.hasBasis_nhds_of_ne_zeroₓ'. -/
 theorem hasBasis_nhds_of_ne_zero {x : Γ₀} (h : x ≠ 0) :
     HasBasis (𝓝 x) (fun i : Unit => True) fun i => {x} :=
   by
@@ -127,27 +187,45 @@ theorem hasBasis_nhds_of_ne_zero {x : Γ₀} (h : x ≠ 0) :
   exact has_basis_pure _
 #align with_zero_topology.has_basis_nhds_of_ne_zero WithZeroTopology.hasBasis_nhds_of_ne_zero
 
+#print WithZeroTopology.hasBasis_nhds_units /-
 theorem hasBasis_nhds_units (γ : Γ₀ˣ) : HasBasis (𝓝 (γ : Γ₀)) (fun i : Unit => True) fun i => {γ} :=
   hasBasis_nhds_of_ne_zero γ.NeZero
 #align with_zero_topology.has_basis_nhds_units WithZeroTopology.hasBasis_nhds_units
+-/
 
+/- warning: with_zero_topology.tendsto_of_ne_zero -> WithZeroTopology.tendsto_of_ne_zero is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {Γ₀ : Type.{u2}} [_inst_1 : LinearOrderedCommGroupWithZero.{u2} Γ₀] {l : Filter.{u1} α} {f : α -> Γ₀} {γ : Γ₀}, (Ne.{succ u2} Γ₀ γ (OfNat.ofNat.{u2} Γ₀ 0 (OfNat.mk.{u2} Γ₀ 0 (Zero.zero.{u2} Γ₀ (MulZeroClass.toHasZero.{u2} Γ₀ (MulZeroOneClass.toMulZeroClass.{u2} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u2} Γ₀ (GroupWithZero.toMonoidWithZero.{u2} Γ₀ (CommGroupWithZero.toGroupWithZero.{u2} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u2} Γ₀ _inst_1)))))))))) -> (Iff (Filter.Tendsto.{u1, u2} α Γ₀ f l (nhds.{u2} Γ₀ (WithZeroTopology.topologicalSpace.{u2} Γ₀ _inst_1) γ)) (Filter.Eventually.{u1} α (fun (x : α) => Eq.{succ u2} Γ₀ (f x) γ) l))
+but is expected to have type
+  forall {α : Type.{u1}} {Γ₀ : Type.{u2}} [_inst_1 : LinearOrderedCommGroupWithZero.{u2} Γ₀] {l : Filter.{u1} α} {f : α -> Γ₀} {γ : Γ₀}, (Ne.{succ u2} Γ₀ γ (OfNat.ofNat.{u2} Γ₀ 0 (Zero.toOfNat0.{u2} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u2} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u2} Γ₀ _inst_1))))) -> (Iff (Filter.Tendsto.{u1, u2} α Γ₀ f l (nhds.{u2} Γ₀ (WithZeroTopology.topologicalSpace.{u2} Γ₀ _inst_1) γ)) (Filter.Eventually.{u1} α (fun (x : α) => Eq.{succ u2} Γ₀ (f x) γ) l))
+Case conversion may be inaccurate. Consider using '#align with_zero_topology.tendsto_of_ne_zero WithZeroTopology.tendsto_of_ne_zeroₓ'. -/
 theorem tendsto_of_ne_zero {γ : Γ₀} (h : γ ≠ 0) : Tendsto f l (𝓝 γ) ↔ ∀ᶠ x in l, f x = γ := by
   rw [nhds_of_ne_zero h, tendsto_pure]
 #align with_zero_topology.tendsto_of_ne_zero WithZeroTopology.tendsto_of_ne_zero
 
+#print WithZeroTopology.tendsto_units /-
 theorem tendsto_units {γ₀ : Γ₀ˣ} : Tendsto f l (𝓝 (γ₀ : Γ₀)) ↔ ∀ᶠ x in l, f x = γ₀ :=
   tendsto_of_ne_zero γ₀.NeZero
 #align with_zero_topology.tendsto_units WithZeroTopology.tendsto_units
+-/
 
+#print WithZeroTopology.Iio_mem_nhds /-
 theorem Iio_mem_nhds (h : γ₁ < γ₂) : Iio γ₂ ∈ 𝓝 γ₁ := by
   rcases eq_or_ne γ₁ 0 with (rfl | h₀) <;> simp [*, h.ne', Iio_mem_nhds_zero]
 #align with_zero_topology.Iio_mem_nhds WithZeroTopology.Iio_mem_nhds
+-/
 
 /-!
 ### Open/closed sets
 -/
 
 
+/- warning: with_zero_topology.is_open_iff -> WithZeroTopology.isOpen_iff is a dubious translation:
+lean 3 declaration is
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {s : Set.{u1} Γ₀}, Iff (IsOpen.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) s) (Or (Not (Membership.Mem.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.hasMem.{u1} Γ₀) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))))))) s)) (Exists.{succ u1} Γ₀ (fun (γ : Γ₀) => Exists.{0} (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) => HasSubset.Subset.{u1} (Set.{u1} Γ₀) (Set.hasSubset.{u1} Γ₀) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ) s))))
+but is expected to have type
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {s : Set.{u1} Γ₀}, Iff (IsOpen.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) s) (Or (Not (Membership.mem.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.instMembershipSet.{u1} Γ₀) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))) s)) (Exists.{succ u1} Γ₀ (fun (γ : Γ₀) => And (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (HasSubset.Subset.{u1} (Set.{u1} Γ₀) (Set.instHasSubsetSet.{u1} Γ₀) (Set.Iio.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ) s))))
+Case conversion may be inaccurate. Consider using '#align with_zero_topology.is_open_iff WithZeroTopology.isOpen_iffₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ : _)(_ : γ ≠ 0), Iio γ ⊆ s :=
   by
@@ -156,6 +234,12 @@ theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ
     has_basis_nhds_zero.mem_iff]
 #align with_zero_topology.is_open_iff WithZeroTopology.isOpen_iff
 
+/- warning: with_zero_topology.is_closed_iff -> WithZeroTopology.isClosed_iff is a dubious translation:
+lean 3 declaration is
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {s : Set.{u1} Γ₀}, Iff (IsClosed.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) s) (Or (Membership.Mem.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.hasMem.{u1} Γ₀) (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1))))))))) s) (Exists.{succ u1} Γ₀ (fun (γ : Γ₀) => Exists.{0} (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) (fun (H : Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (OfNat.mk.{u1} Γ₀ 0 (Zero.zero.{u1} Γ₀ (MulZeroClass.toHasZero.{u1} Γ₀ (MulZeroOneClass.toMulZeroClass.{u1} Γ₀ (MonoidWithZero.toMulZeroOneClass.{u1} Γ₀ (GroupWithZero.toMonoidWithZero.{u1} Γ₀ (CommGroupWithZero.toGroupWithZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toCommGroupWithZero.{u1} Γ₀ _inst_1)))))))))) => HasSubset.Subset.{u1} (Set.{u1} Γ₀) (Set.hasSubset.{u1} Γ₀) s (Set.Ici.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ)))))
+but is expected to have type
+  forall {Γ₀ : Type.{u1}} [_inst_1 : LinearOrderedCommGroupWithZero.{u1} Γ₀] {s : Set.{u1} Γ₀}, Iff (IsClosed.{u1} Γ₀ (WithZeroTopology.topologicalSpace.{u1} Γ₀ _inst_1) s) (Or (Membership.mem.{u1, u1} Γ₀ (Set.{u1} Γ₀) (Set.instMembershipSet.{u1} Γ₀) (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1)))) s) (Exists.{succ u1} Γ₀ (fun (γ : Γ₀) => And (Ne.{succ u1} Γ₀ γ (OfNat.ofNat.{u1} Γ₀ 0 (Zero.toOfNat0.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toZero.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) (HasSubset.Subset.{u1} (Set.{u1} Γ₀) (Set.instHasSubsetSet.{u1} Γ₀) s (Set.Ici.{u1} Γ₀ (PartialOrder.toPreorder.{u1} Γ₀ (OrderedCommMonoid.toPartialOrder.{u1} Γ₀ (LinearOrderedCommMonoid.toOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommMonoidWithZero.toLinearOrderedCommMonoid.{u1} Γ₀ (LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero.{u1} Γ₀ _inst_1))))) γ)))))
+Case conversion may be inaccurate. Consider using '#align with_zero_topology.is_closed_iff WithZeroTopology.isClosed_iffₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem isClosed_iff {s : Set Γ₀} : IsClosed s ↔ (0 : Γ₀) ∈ s ∨ ∃ (γ : _)(_ : γ ≠ 0), s ⊆ Ici γ :=
   by
@@ -163,15 +247,18 @@ theorem isClosed_iff {s : Set Γ₀} : IsClosed s ↔ (0 : Γ₀) ∈ s ∨ ∃
     compl_subset_compl]
 #align with_zero_topology.is_closed_iff WithZeroTopology.isClosed_iff
 
+#print WithZeroTopology.isOpen_Iio /-
 theorem isOpen_Iio {a : Γ₀} : IsOpen (Iio a) :=
   isOpen_iff.mpr <| imp_iff_not_or.mp fun ha => ⟨a, ne_of_gt ha, Subset.rfl⟩
 #align with_zero_topology.is_open_Iio WithZeroTopology.isOpen_Iio
+-/
 
 /-!
 ### Instances
 -/
 
 
+#print WithZeroTopology.orderClosedTopology /-
 /-- The topology on a linearly ordered group with zero element adjoined is compatible with the order
 structure: the set `{p : Γ₀ × Γ₀ | p.1 ≤ p.2}` is closed. -/
 protected theorem orderClosedTopology : OrderClosedTopology Γ₀ :=
@@ -183,9 +270,11 @@ protected theorem orderClosedTopology : OrderClosedTopology Γ₀ :=
       rw [nhds_prod_eq, nhds_of_ne_zero (zero_le'.trans_lt hab).ne', pure_prod]
       exact Iio_mem_nhds hab }
 #align with_zero_topology.order_closed_topology WithZeroTopology.orderClosedTopology
+-/
 
 attribute [scoped instance] WithZeroTopology.orderClosedTopology
 
+#print WithZeroTopology.t3Space /-
 /-- The topology on a linearly ordered group with zero element adjoined is T₃. -/
 theorem t3Space : T3Space Γ₀ :=
   {
@@ -201,6 +290,7 @@ theorem t3Space : T3Space Γ₀ :=
             has_basis_nhds_zero.lift'_closure_eq_self fun x hx =>
               is_closed_iff.2 <| Or.inl <| zero_lt_iff.2 hx }
 #align with_zero_topology.t3_space WithZeroTopology.t3Space
+-/
 
 attribute [scoped instance] WithZeroTopology.t3Space
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

@@ -214,13 +214,14 @@ protected theorem continuousMul : ContinuousMul Γ₀ :=
     · have := tendsto.comp (this y x (le_of_not_le hle)) (continuous_swap.tendsto (x, y))
       simpa only [mul_comm, Function.comp, Prod.swap]
     rcases eq_or_ne x 0 with (rfl | hx) <;> [rcases eq_or_ne y 0 with (rfl | hy), skip]
-    · rw [ContinuousAt, zero_mul]
+    · rw [ContinuousAt, MulZeroClass.zero_mul]
       refine'
         ((has_basis_nhds_zero.prod_nhds has_basis_nhds_zero).tendsto_iffₓ has_basis_nhds_zero).2
           fun γ hγ => ⟨(γ, 1), ⟨hγ, one_ne_zero⟩, _⟩
       rintro ⟨x, y⟩ ⟨hx : x < γ, hy : y < 1⟩
       exact (mul_lt_mul₀ hx hy).trans_eq (mul_one γ)
-    · rw [ContinuousAt, zero_mul, nhds_prod_eq, nhds_of_ne_zero hy, prod_pure, tendsto_map'_iff]
+    · rw [ContinuousAt, MulZeroClass.zero_mul, nhds_prod_eq, nhds_of_ne_zero hy, prod_pure,
+        tendsto_map'_iff]
       refine' (has_basis_nhds_zero.tendsto_iff has_basis_nhds_zero).2 fun γ hγ => _
       refine' ⟨γ / y, div_ne_zero hγ hy, fun x hx => _⟩
       calc

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

@@ -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.with_zero_topology
-! leanprover-community/mathlib commit 92ca63f0fb391a9ca5f22d2409a6080e786d99f7
+! leanprover-community/mathlib commit 3e0c4d76b6ebe9dfafb67d16f7286d2731ed6064
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -30,11 +30,9 @@ absolute value (resp. `p`-adic absolute value) on `ℚ` is extended to `ℝ` (re
 
 ## Implementation notes
 
-This topology is not defined as an instance since it may not be the desired topology on
-a linearly ordered commutative group with zero. You can locally activate this topology using
-`local attribute [instance] linear_ordered_comm_group_with_zero.topological_space`
-All other instances will (`ordered_topology`, `t3_space`, `has_continuous_mul`) then follow.
-
+This topology is not defined as a global instance since it may not be the desired topology on a
+linearly ordered commutative group with zero. You can locally activate this topology using
+`open_locale with_zero_topology`.
 -/
 
 
@@ -42,7 +40,7 @@ open Topology Filter
 
 open TopologicalSpace Filter Set Function
 
-namespace LinearOrderedCommGroupWithZero
+namespace WithZeroTopology
 
 variable {α Γ₀ : Type _} [LinearOrderedCommGroupWithZero Γ₀] {γ γ₁ γ₂ : Γ₀} {l : Filter α}
   {f : α → Γ₀}
@@ -52,14 +50,14 @@ variable {α Γ₀ : Type _} [LinearOrderedCommGroupWithZero Γ₀] {γ γ₁ γ
 A subset U is open if 0 ∉ U or if there is an invertible element γ₀ such that {γ | γ < γ₀} ⊆ U. -/
 protected def topologicalSpace : TopologicalSpace Γ₀ :=
   TopologicalSpace.mkOfNhds <| update pure 0 <| ⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ)
-#align linear_ordered_comm_group_with_zero.topological_space LinearOrderedCommGroupWithZero.topologicalSpace
+#align with_zero_topology.topological_space WithZeroTopology.topologicalSpace
 
-attribute [local instance] LinearOrderedCommGroupWithZero.topologicalSpace
+attribute [scoped instance] WithZeroTopology.topologicalSpace
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ)) :=
   funext <| nhds_mkOfNhds_single <| le_infᵢ₂ fun γ h₀ => le_principal_iff.2 <| zero_lt_iff.2 h₀
-#align linear_ordered_comm_group_with_zero.nhds_eq_update LinearOrderedCommGroupWithZero.nhds_eq_update
+#align with_zero_topology.nhds_eq_update WithZeroTopology.nhds_eq_update
 
 /-!
 ### Neighbourhoods of zero
@@ -68,7 +66,7 @@ theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem nhds_zero : 𝓝 (0 : Γ₀) = ⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ) := by rw [nhds_eq_update, update_same]
-#align linear_ordered_comm_group_with_zero.nhds_zero LinearOrderedCommGroupWithZero.nhds_zero
+#align with_zero_topology.nhds_zero WithZeroTopology.nhds_zero
 
 /-- In a linearly ordered group with zero element adjoined, `U` is a neighbourhood of `0` if and
 only if there exists a nonzero element `γ₀` such that `Iio γ₀ ⊆ U`. -/
@@ -77,22 +75,22 @@ theorem hasBasis_nhds_zero : (𝓝 (0 : Γ₀)).HasBasis (fun γ : Γ₀ => γ 
   rw [nhds_zero]
   refine' has_basis_binfi_principal _ ⟨1, one_ne_zero⟩
   exact directedOn_iff_directed.2 (directed_of_inf fun a b hab => Iio_subset_Iio hab)
-#align linear_ordered_comm_group_with_zero.has_basis_nhds_zero LinearOrderedCommGroupWithZero.hasBasis_nhds_zero
+#align with_zero_topology.has_basis_nhds_zero WithZeroTopology.hasBasis_nhds_zero
 
 theorem Iio_mem_nhds_zero (hγ : γ ≠ 0) : Iio γ ∈ 𝓝 (0 : Γ₀) :=
   hasBasis_nhds_zero.mem_of_mem hγ
-#align linear_ordered_comm_group_with_zero.Iio_mem_nhds_zero LinearOrderedCommGroupWithZero.Iio_mem_nhds_zero
+#align with_zero_topology.Iio_mem_nhds_zero WithZeroTopology.Iio_mem_nhds_zero
 
 /-- If `γ` is an invertible element of a linearly ordered group with zero element adjoined, then
 `Iio (γ : Γ₀)` is a neighbourhood of `0`. -/
 theorem nhds_zero_of_units (γ : Γ₀ˣ) : Iio ↑γ ∈ 𝓝 (0 : Γ₀) :=
   Iio_mem_nhds_zero γ.NeZero
-#align linear_ordered_comm_group_with_zero.nhds_zero_of_units LinearOrderedCommGroupWithZero.nhds_zero_of_units
+#align with_zero_topology.nhds_zero_of_units WithZeroTopology.nhds_zero_of_units
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ₀ «expr ≠ » 0) -/
 theorem tendsto_zero : Tendsto f l (𝓝 (0 : Γ₀)) ↔ ∀ (γ₀) (_ : γ₀ ≠ 0), ∀ᶠ x in l, f x < γ₀ := by
   simp [nhds_zero]
-#align linear_ordered_comm_group_with_zero.tendsto_zero LinearOrderedCommGroupWithZero.tendsto_zero
+#align with_zero_topology.tendsto_zero WithZeroTopology.tendsto_zero
 
 /-!
 ### Neighbourhoods of non-zero elements
@@ -104,46 +102,46 @@ element. -/
 @[simp]
 theorem nhds_of_ne_zero {γ : Γ₀} (h₀ : γ ≠ 0) : 𝓝 γ = pure γ := by
   rw [nhds_eq_update, update_noteq h₀]
-#align linear_ordered_comm_group_with_zero.nhds_of_ne_zero LinearOrderedCommGroupWithZero.nhds_of_ne_zero
+#align with_zero_topology.nhds_of_ne_zero WithZeroTopology.nhds_of_ne_zero
 
 /-- The neighbourhood filter of an invertible element consists of all sets containing that
 element. -/
 theorem nhds_coe_units (γ : Γ₀ˣ) : 𝓝 (γ : Γ₀) = pure (γ : Γ₀) :=
   nhds_of_ne_zero γ.NeZero
-#align linear_ordered_comm_group_with_zero.nhds_coe_units LinearOrderedCommGroupWithZero.nhds_coe_units
+#align with_zero_topology.nhds_coe_units WithZeroTopology.nhds_coe_units
 
 /-- If `γ` is an invertible element of a linearly ordered group with zero element adjoined, then
 `{γ}` is a neighbourhood of `γ`. -/
 theorem singleton_mem_nhds_of_units (γ : Γ₀ˣ) : ({γ} : Set Γ₀) ∈ 𝓝 (γ : Γ₀) := by simp
-#align linear_ordered_comm_group_with_zero.singleton_mem_nhds_of_units LinearOrderedCommGroupWithZero.singleton_mem_nhds_of_units
+#align with_zero_topology.singleton_mem_nhds_of_units WithZeroTopology.singleton_mem_nhds_of_units
 
 /-- If `γ` is a nonzero element of a linearly ordered group with zero element adjoined, then `{γ}`
 is a neighbourhood of `γ`. -/
 theorem singleton_mem_nhds_of_ne_zero (h : γ ≠ 0) : ({γ} : Set Γ₀) ∈ 𝓝 (γ : Γ₀) := by simp [h]
-#align linear_ordered_comm_group_with_zero.singleton_mem_nhds_of_ne_zero LinearOrderedCommGroupWithZero.singleton_mem_nhds_of_ne_zero
+#align with_zero_topology.singleton_mem_nhds_of_ne_zero WithZeroTopology.singleton_mem_nhds_of_ne_zero
 
 theorem hasBasis_nhds_of_ne_zero {x : Γ₀} (h : x ≠ 0) :
     HasBasis (𝓝 x) (fun i : Unit => True) fun i => {x} :=
   by
   rw [nhds_of_ne_zero h]
   exact has_basis_pure _
-#align linear_ordered_comm_group_with_zero.has_basis_nhds_of_ne_zero LinearOrderedCommGroupWithZero.hasBasis_nhds_of_ne_zero
+#align with_zero_topology.has_basis_nhds_of_ne_zero WithZeroTopology.hasBasis_nhds_of_ne_zero
 
 theorem hasBasis_nhds_units (γ : Γ₀ˣ) : HasBasis (𝓝 (γ : Γ₀)) (fun i : Unit => True) fun i => {γ} :=
   hasBasis_nhds_of_ne_zero γ.NeZero
-#align linear_ordered_comm_group_with_zero.has_basis_nhds_units LinearOrderedCommGroupWithZero.hasBasis_nhds_units
+#align with_zero_topology.has_basis_nhds_units WithZeroTopology.hasBasis_nhds_units
 
 theorem tendsto_of_ne_zero {γ : Γ₀} (h : γ ≠ 0) : Tendsto f l (𝓝 γ) ↔ ∀ᶠ x in l, f x = γ := by
   rw [nhds_of_ne_zero h, tendsto_pure]
-#align linear_ordered_comm_group_with_zero.tendsto_of_ne_zero LinearOrderedCommGroupWithZero.tendsto_of_ne_zero
+#align with_zero_topology.tendsto_of_ne_zero WithZeroTopology.tendsto_of_ne_zero
 
 theorem tendsto_units {γ₀ : Γ₀ˣ} : Tendsto f l (𝓝 (γ₀ : Γ₀)) ↔ ∀ᶠ x in l, f x = γ₀ :=
   tendsto_of_ne_zero γ₀.NeZero
-#align linear_ordered_comm_group_with_zero.tendsto_units LinearOrderedCommGroupWithZero.tendsto_units
+#align with_zero_topology.tendsto_units WithZeroTopology.tendsto_units
 
 theorem Iio_mem_nhds (h : γ₁ < γ₂) : Iio γ₂ ∈ 𝓝 γ₁ := by
   rcases eq_or_ne γ₁ 0 with (rfl | h₀) <;> simp [*, h.ne', Iio_mem_nhds_zero]
-#align linear_ordered_comm_group_with_zero.Iio_mem_nhds LinearOrderedCommGroupWithZero.Iio_mem_nhds
+#align with_zero_topology.Iio_mem_nhds WithZeroTopology.Iio_mem_nhds
 
 /-!
 ### Open/closed sets
@@ -156,18 +154,18 @@ theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ
   rw [isOpen_iff_mem_nhds, ← and_forall_ne (0 : Γ₀)]
   simp (config := { contextual := true }) [nhds_of_ne_zero, imp_iff_not_or,
     has_basis_nhds_zero.mem_iff]
-#align linear_ordered_comm_group_with_zero.is_open_iff LinearOrderedCommGroupWithZero.isOpen_iff
+#align with_zero_topology.is_open_iff WithZeroTopology.isOpen_iff
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem isClosed_iff {s : Set Γ₀} : IsClosed s ↔ (0 : Γ₀) ∈ s ∨ ∃ (γ : _)(_ : γ ≠ 0), s ⊆ Ici γ :=
   by
   simp only [← isOpen_compl_iff, is_open_iff, mem_compl_iff, Classical.not_not, ← compl_Ici,
     compl_subset_compl]
-#align linear_ordered_comm_group_with_zero.is_closed_iff LinearOrderedCommGroupWithZero.isClosed_iff
+#align with_zero_topology.is_closed_iff WithZeroTopology.isClosed_iff
 
 theorem isOpen_Iio {a : Γ₀} : IsOpen (Iio a) :=
   isOpen_iff.mpr <| imp_iff_not_or.mp fun ha => ⟨a, ne_of_gt ha, Subset.rfl⟩
-#align linear_ordered_comm_group_with_zero.is_open_Iio LinearOrderedCommGroupWithZero.isOpen_Iio
+#align with_zero_topology.is_open_Iio WithZeroTopology.isOpen_Iio
 
 /-!
 ### Instances
@@ -176,33 +174,39 @@ theorem isOpen_Iio {a : Γ₀} : IsOpen (Iio a) :=
 
 /-- The topology on a linearly ordered group with zero element adjoined is compatible with the order
 structure: the set `{p : Γ₀ × Γ₀ | p.1 ≤ p.2}` is closed. -/
-instance (priority := 100) orderClosedTopology : OrderClosedTopology Γ₀
-    where isClosed_le' :=
-    by
-    simp only [← isOpen_compl_iff, compl_set_of, not_le, isOpen_iff_mem_nhds]
-    rintro ⟨a, b⟩ (hab : b < a)
-    rw [nhds_prod_eq, nhds_of_ne_zero (zero_le'.trans_lt hab).ne', pure_prod]
-    exact Iio_mem_nhds hab
-#align linear_ordered_comm_group_with_zero.order_closed_topology LinearOrderedCommGroupWithZero.orderClosedTopology
+protected theorem orderClosedTopology : OrderClosedTopology Γ₀ :=
+  {
+    isClosed_le' :=
+      by
+      simp only [← isOpen_compl_iff, compl_set_of, not_le, isOpen_iff_mem_nhds]
+      rintro ⟨a, b⟩ (hab : b < a)
+      rw [nhds_prod_eq, nhds_of_ne_zero (zero_le'.trans_lt hab).ne', pure_prod]
+      exact Iio_mem_nhds hab }
+#align with_zero_topology.order_closed_topology WithZeroTopology.orderClosedTopology
+
+attribute [scoped instance] WithZeroTopology.orderClosedTopology
 
 /-- The topology on a linearly ordered group with zero element adjoined is T₃. -/
-instance (priority := 100) t3Space : T3Space Γ₀
-    where to_regularSpace :=
-    RegularSpace.ofLift'_closure fun γ =>
-      by
-      rcases ne_or_eq γ 0 with (h₀ | rfl)
-      ·
-        rw [nhds_of_ne_zero h₀, lift'_pure (monotone_closure Γ₀), closure_singleton,
-          principal_singleton]
-      ·
-        exact
-          has_basis_nhds_zero.lift'_closure_eq_self fun x hx =>
-            is_closed_iff.2 <| Or.inl <| zero_lt_iff.2 hx
-#align linear_ordered_comm_group_with_zero.t3_space LinearOrderedCommGroupWithZero.t3Space
+theorem t3Space : T3Space Γ₀ :=
+  {
+    to_regularSpace :=
+      RegularSpace.ofLift'_closure fun γ =>
+        by
+        rcases ne_or_eq γ 0 with (h₀ | rfl)
+        ·
+          rw [nhds_of_ne_zero h₀, lift'_pure (monotone_closure Γ₀), closure_singleton,
+            principal_singleton]
+        ·
+          exact
+            has_basis_nhds_zero.lift'_closure_eq_self fun x hx =>
+              is_closed_iff.2 <| Or.inl <| zero_lt_iff.2 hx }
+#align with_zero_topology.t3_space WithZeroTopology.t3Space
+
+attribute [scoped instance] WithZeroTopology.t3Space
 
 /-- The topology on a linearly ordered group with zero element adjoined makes it a topological
 monoid. -/
-instance (priority := 100) : ContinuousMul Γ₀ :=
+protected theorem continuousMul : ContinuousMul Γ₀ :=
   ⟨by
     rw [continuous_iff_continuousAt]
     rintro ⟨x, y⟩
@@ -226,11 +230,17 @@ instance (priority := 100) : ContinuousMul Γ₀ :=
     · have hy : y ≠ 0 := ((zero_lt_iff.mpr hx).trans_le hle).ne'
       rw [ContinuousAt, nhds_prod_eq, nhds_of_ne_zero hx, nhds_of_ne_zero hy, prod_pure_pure]
       exact pure_le_nhds (x * y)⟩
+#align with_zero_topology.has_continuous_mul WithZeroTopology.continuousMul
+
+attribute [scoped instance] WithZeroTopology.continuousMul
 
-instance (priority := 100) : HasContinuousInv₀ Γ₀ :=
+protected theorem hasContinuousInv₀ : HasContinuousInv₀ Γ₀ :=
   ⟨fun γ h => by
     rw [ContinuousAt, nhds_of_ne_zero h]
     exact pure_le_nhds γ⁻¹⟩
+#align with_zero_topology.has_continuous_inv₀ WithZeroTopology.hasContinuousInv₀
+
+attribute [scoped instance] WithZeroTopology.hasContinuousInv₀
 
-end LinearOrderedCommGroupWithZero
+end WithZeroTopology
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/4c586d291f189eecb9d00581aeb3dd998ac34442

@@ -47,7 +47,7 @@ namespace LinearOrderedCommGroupWithZero
 variable {α Γ₀ : Type _} [LinearOrderedCommGroupWithZero Γ₀] {γ γ₁ γ₂ : Γ₀} {l : Filter α}
   {f : α → Γ₀}
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 /-- The topology on a linearly ordered commutative group with a zero element adjoined.
 A subset U is open if 0 ∉ U or if there is an invertible element γ₀ such that {γ | γ < γ₀} ⊆ U. -/
 protected def topologicalSpace : TopologicalSpace Γ₀ :=
@@ -56,7 +56,7 @@ protected def topologicalSpace : TopologicalSpace Γ₀ :=
 
 attribute [local instance] LinearOrderedCommGroupWithZero.topologicalSpace
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ)) :=
   funext <| nhds_mkOfNhds_single <| le_infᵢ₂ fun γ h₀ => le_principal_iff.2 <| zero_lt_iff.2 h₀
 #align linear_ordered_comm_group_with_zero.nhds_eq_update LinearOrderedCommGroupWithZero.nhds_eq_update
@@ -66,7 +66,7 @@ theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (
 -/
 
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem nhds_zero : 𝓝 (0 : Γ₀) = ⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ) := by rw [nhds_eq_update, update_same]
 #align linear_ordered_comm_group_with_zero.nhds_zero LinearOrderedCommGroupWithZero.nhds_zero
 
@@ -89,7 +89,7 @@ theorem nhds_zero_of_units (γ : Γ₀ˣ) : Iio ↑γ ∈ 𝓝 (0 : Γ₀) :=
   Iio_mem_nhds_zero γ.NeZero
 #align linear_ordered_comm_group_with_zero.nhds_zero_of_units LinearOrderedCommGroupWithZero.nhds_zero_of_units
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (γ₀ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ₀ «expr ≠ » 0) -/
 theorem tendsto_zero : Tendsto f l (𝓝 (0 : Γ₀)) ↔ ∀ (γ₀) (_ : γ₀ ≠ 0), ∀ᶠ x in l, f x < γ₀ := by
   simp [nhds_zero]
 #align linear_ordered_comm_group_with_zero.tendsto_zero LinearOrderedCommGroupWithZero.tendsto_zero
@@ -150,7 +150,7 @@ theorem Iio_mem_nhds (h : γ₁ < γ₂) : Iio γ₂ ∈ 𝓝 γ₁ := by
 -/
 
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ : _)(_ : γ ≠ 0), Iio γ ⊆ s :=
   by
   rw [isOpen_iff_mem_nhds, ← and_forall_ne (0 : Γ₀)]
@@ -158,7 +158,7 @@ theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ (γ
     has_basis_nhds_zero.mem_iff]
 #align linear_ordered_comm_group_with_zero.is_open_iff LinearOrderedCommGroupWithZero.isOpen_iff
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (γ «expr ≠ » 0) -/
 theorem isClosed_iff {s : Set Γ₀} : IsClosed s ↔ (0 : Γ₀) ∈ s ∨ ∃ (γ : _)(_ : γ ≠ 0), s ⊆ Ici γ :=
   by
   simp only [← isOpen_compl_iff, is_open_iff, mem_compl_iff, Classical.not_not, ← compl_Ici,

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

Reconstitute the file Algebra.Order.Monoid.WithZero from three files:

• Algebra.Order.Monoid.WithZero.Defs
• Algebra.Order.Monoid.WithZero.Basic
• Algebra.Order.WithZero

Avoid importing it in many files. Most uses were just to get le_zero_iff to work on Nat.

Before

After

@@ -3,7 +3,6 @@ Copyright (c) 2021 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot
 -/
-import Mathlib.Algebra.Order.WithZero
 import Mathlib.Topology.Algebra.GroupWithZero
 import Mathlib.Topology.Order.OrderClosed
 

Lemma names around cancellation of multiplication and division are a mess.

This PR renames a handful of them according to the following table (each big row contains the multiplicative statement, then the three rows contain the GroupWithZero lemma name, the Group lemma, the AddGroup lemma name).

| Statement | New name | Old name | |

@@ -197,7 +197,7 @@ scoped instance (priority := 100) : ContinuousMul Γ₀ where
       refine' (hasBasis_nhds_zero.tendsto_iff hasBasis_nhds_zero).2 fun γ hγ => _
       refine' ⟨γ / y, div_ne_zero hγ hy, fun x hx => _⟩
       calc x * y < γ / y * y := mul_lt_right₀ _ hx hy
-      _ = γ := div_mul_cancel _ hy
+      _ = γ := div_mul_cancel₀ _ hy
     · have hy : y ≠ 0 := ((zero_lt_iff.mpr hx).trans_le hle).ne'
       rw [nhds_prod_eq, nhds_of_ne_zero hx, nhds_of_ne_zero hy, prod_pure_pure]
       exact pure_le_nhds (x * y)

It's more specialized than mkOfNhds. Also golf and rename lemmas about nhdsAdjoint.

@@ -42,18 +42,19 @@ variable {α Γ₀ : Type*} [LinearOrderedCommGroupWithZero Γ₀] {γ γ₁ γ
 /-- The topology on a linearly ordered commutative group with a zero element adjoined.
 A subset U is open if 0 ∉ U or if there is an invertible element γ₀ such that {γ | γ < γ₀} ⊆ U. -/
 scoped instance (priority := 100) topologicalSpace : TopologicalSpace Γ₀ :=
-  TopologicalSpace.mkOfNhds <| update pure 0 <| ⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ)
+  nhdsAdjoint 0 <| ⨅ γ ≠ 0, 𝓟 (Iio γ)
 #align with_zero_topology.topological_space WithZeroTopology.topologicalSpace
 
-theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ)) :=
-  funext <| nhds_mkOfNhds_single <| le_iInf₂ fun _ h₀ => le_principal_iff.2 <| zero_lt_iff.2 h₀
-#align with_zero_topology.nhds_eq_update WithZeroTopology.nhds_eq_update
+theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ γ ≠ 0, 𝓟 (Iio γ)) := by
+   rw [nhds_nhdsAdjoint, sup_of_le_right]
+   exact le_iInf₂ fun γ hγ ↦ le_principal_iff.2 <| zero_lt_iff.2 hγ
+ #align with_zero_topology.nhds_eq_update WithZeroTopology.nhds_eq_update
 
 /-!
 ### Neighbourhoods of zero
 -/
 
-theorem nhds_zero : 𝓝 (0 : Γ₀) = ⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ) := by
+theorem nhds_zero : 𝓝 (0 : Γ₀) = ⨅ γ ≠ 0, 𝓟 (Iio γ) := by
   rw [nhds_eq_update, update_same]
 #align with_zero_topology.nhds_zero WithZeroTopology.nhds_zero
 
@@ -86,8 +87,8 @@ theorem tendsto_zero : Tendsto f l (𝓝 (0 : Γ₀)) ↔ ∀ (γ₀) (_ : γ₀
 /-- The neighbourhood filter of a nonzero element consists of all sets containing that
 element. -/
 @[simp]
-theorem nhds_of_ne_zero {γ : Γ₀} (h₀ : γ ≠ 0) : 𝓝 γ = pure γ := by
-  rw [nhds_eq_update, update_noteq h₀]
+theorem nhds_of_ne_zero {γ : Γ₀} (h₀ : γ ≠ 0) : 𝓝 γ = pure γ :=
+  nhds_nhdsAdjoint_of_ne _ h₀
 #align with_zero_topology.nhds_of_ne_zero WithZeroTopology.nhds_of_ne_zero
 
 /-- The neighbourhood filter of an invertible element consists of all sets containing that

@@ -5,7 +5,7 @@ Authors: Patrick Massot
 -/
 import Mathlib.Algebra.Order.WithZero
 import Mathlib.Topology.Algebra.GroupWithZero
-import Mathlib.Topology.Order.Basic
+import Mathlib.Topology.Order.OrderClosed
 
 #align_import topology.algebra.with_zero_topology from "leanprover-community/mathlib"@"3e0c4d76b6ebe9dfafb67d16f7286d2731ed6064"
 

New lemmas / instances

• An archimedean ordered semiring is directed upwards.
• Filter.hasAntitoneBasis_atTop;
• Filter.HasAntitoneBasis.iInf_principal;

Fix typos

• Docstrings: "if the agree" -> "if they agree".
• ProbabilityTheory.measure_eq_zero_or_one_of_indepSetCat_self -> ProbabilityTheory.measure_eq_zero_or_one_of_indepSet_self.

Weaken typeclass assumptions

From a semilattice to a directed type

• MeasureTheory.tendsto_measure_iUnion;
• MeasureTheory.tendsto_measure_iInter;
• Monotone.directed_le, Monotone.directed_ge;
• Antitone.directed_le, Antitone.directed_ge;
• directed_of_sup, renamed to directed_of_isDirected_le;
• directed_of_inf, renamed to directed_of_isDirected_ge;

From a strict ordered semiring to an ordered semiring

• tendsto_nat_cast_atTop_atTop;
• Filter.Eventually.nat_cast_atTop;
• atTop_hasAntitoneBasis_of_archimedean;

@@ -62,7 +62,7 @@ only if there exists a nonzero element `γ₀` such that `Iio γ₀ ⊆ U`. -/
 theorem hasBasis_nhds_zero : (𝓝 (0 : Γ₀)).HasBasis (fun γ : Γ₀ => γ ≠ 0) Iio := by
   rw [nhds_zero]
   refine' hasBasis_biInf_principal _ ⟨1, one_ne_zero⟩
-  exact directedOn_iff_directed.2 (directed_of_inf fun a b hab => Iio_subset_Iio hab)
+  exact directedOn_iff_directed.2 (Monotone.directed_ge fun a b hab => Iio_subset_Iio hab)
 #align with_zero_topology.has_basis_nhds_zero WithZeroTopology.hasBasis_nhds_zero
 
 theorem Iio_mem_nhds_zero (hγ : γ ≠ 0) : Iio γ ∈ 𝓝 (0 : Γ₀) :=

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

This has nice performance benefits.

@@ -36,7 +36,7 @@ open Topology Filter TopologicalSpace Filter Set Function
 
 namespace WithZeroTopology
 
-variable {α Γ₀ : Type _} [LinearOrderedCommGroupWithZero Γ₀] {γ γ₁ γ₂ : Γ₀} {l : Filter α}
+variable {α Γ₀ : Type*} [LinearOrderedCommGroupWithZero Γ₀] {γ γ₁ γ₂ : Γ₀} {l : Filter α}
   {f : α → Γ₀}
 
 /-- The topology on a linearly ordered commutative group with a zero element adjoined.

• depends on: #5966

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

@@ -2,16 +2,13 @@
 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.with_zero_topology
-! leanprover-community/mathlib commit 3e0c4d76b6ebe9dfafb67d16f7286d2731ed6064
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Order.WithZero
 import Mathlib.Topology.Algebra.GroupWithZero
 import Mathlib.Topology.Order.Basic
 
+#align_import topology.algebra.with_zero_topology from "leanprover-community/mathlib"@"3e0c4d76b6ebe9dfafb67d16f7286d2731ed6064"
+
 /-!
 # The topology on linearly ordered commutative groups with zero
 

@@ -45,10 +45,10 @@ variable {α Γ₀ : Type _} [LinearOrderedCommGroupWithZero Γ₀] {γ γ₁ γ
 /-- The topology on a linearly ordered commutative group with a zero element adjoined.
 A subset U is open if 0 ∉ U or if there is an invertible element γ₀ such that {γ | γ < γ₀} ⊆ U. -/
 scoped instance (priority := 100) topologicalSpace : TopologicalSpace Γ₀ :=
-  TopologicalSpace.mkOfNhds <| update pure 0 <| ⨅ (γ) (_h : γ ≠ 0), 𝓟 (Iio γ)
+  TopologicalSpace.mkOfNhds <| update pure 0 <| ⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ)
 #align with_zero_topology.topological_space WithZeroTopology.topologicalSpace
 
-theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (γ) (_h : γ ≠ 0), 𝓟 (Iio γ)) :=
+theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ)) :=
   funext <| nhds_mkOfNhds_single <| le_iInf₂ fun _ h₀ => le_principal_iff.2 <| zero_lt_iff.2 h₀
 #align with_zero_topology.nhds_eq_update WithZeroTopology.nhds_eq_update
 
@@ -56,7 +56,7 @@ theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (
 ### Neighbourhoods of zero
 -/
 
-theorem nhds_zero : 𝓝 (0 : Γ₀) = ⨅ (γ) (_h : γ ≠ 0), 𝓟 (Iio γ) := by
+theorem nhds_zero : 𝓝 (0 : Γ₀) = ⨅ (γ) (_ : γ ≠ 0), 𝓟 (Iio γ) := by
   rw [nhds_eq_update, update_same]
 #align with_zero_topology.nhds_zero WithZeroTopology.nhds_zero
 

The main breaking change is that tac <;> [t1, t2] is now written tac <;> [t1; t2], to avoid clashing with tactics like cases and use that take comma-separated lists.

@@ -189,7 +189,7 @@ scoped instance (priority := 100) : ContinuousMul Γ₀ where
     wlog hle : x ≤ y generalizing x y
     · have := (this y x (le_of_not_le hle)).comp (continuous_swap.tendsto (x, y))
       simpa only [mul_comm, Function.comp, Prod.swap] using this
-    rcases eq_or_ne x 0 with (rfl | hx) <;> [rcases eq_or_ne y 0 with (rfl | hy), skip]
+    rcases eq_or_ne x 0 with (rfl | hx) <;> [rcases eq_or_ne y 0 with (rfl | hy); skip]
     · rw [zero_mul]
       refine ((hasBasis_nhds_zero.prod_nhds hasBasis_nhds_zero).tendsto_iff hasBasis_nhds_zero).2
         fun γ hγ => ⟨(γ, 1), ⟨hγ, one_ne_zero⟩, ?_⟩

This makes a mathlib4 version of mathlib3's tactic.basic, now called Mathlib.Tactic.Common, which imports all tactics which do not have significant theory requirements, and then is imported all across the base of the hierarchy.

This ensures that all common tactics are available nearly everywhere in the library, rather than having to be imported one-by-one as you need them.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -11,7 +11,6 @@ Authors: Patrick Massot
 import Mathlib.Algebra.Order.WithZero
 import Mathlib.Topology.Algebra.GroupWithZero
 import Mathlib.Topology.Order.Basic
-import Mathlib.Tactic.WLOG
 
 /-!
 # The topology on linearly ordered commutative groups with zero

As discussed on Zulip

Renames

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

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

@@ -50,7 +50,7 @@ scoped instance (priority := 100) topologicalSpace : TopologicalSpace Γ₀ :=
 #align with_zero_topology.topological_space WithZeroTopology.topologicalSpace
 
 theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ (γ) (_h : γ ≠ 0), 𝓟 (Iio γ)) :=
-  funext <| nhds_mkOfNhds_single <| le_infᵢ₂ fun _ h₀ => le_principal_iff.2 <| zero_lt_iff.2 h₀
+  funext <| nhds_mkOfNhds_single <| le_iInf₂ fun _ h₀ => le_principal_iff.2 <| zero_lt_iff.2 h₀
 #align with_zero_topology.nhds_eq_update WithZeroTopology.nhds_eq_update
 
 /-!
@@ -65,7 +65,7 @@ theorem nhds_zero : 𝓝 (0 : Γ₀) = ⨅ (γ) (_h : γ ≠ 0), 𝓟 (Iio γ) :
 only if there exists a nonzero element `γ₀` such that `Iio γ₀ ⊆ U`. -/
 theorem hasBasis_nhds_zero : (𝓝 (0 : Γ₀)).HasBasis (fun γ : Γ₀ => γ ≠ 0) Iio := by
   rw [nhds_zero]
-  refine' hasBasis_binfᵢ_principal _ ⟨1, one_ne_zero⟩
+  refine' hasBasis_biInf_principal _ ⟨1, one_ne_zero⟩
   exact directedOn_iff_directed.2 (directed_of_inf fun a b hab => Iio_subset_Iio hab)
 #align with_zero_topology.has_basis_nhds_zero WithZeroTopology.hasBasis_nhds_zero