topology.bornology.basic ⟷ Mathlib.Topology.Bornology.Basic

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

@@ -59,7 +59,7 @@ class Bornology (α : Type _) where
 #align bornology Bornology
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
 #print Bornology.ofBounded /-
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/
@@ -83,7 +83,7 @@ def Bornology.ofBounded {α : Type _} (B : Set (Set α)) (empty_mem : ∅ ∈ B)
 #align bornology.of_bounded Bornology.ofBounded
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
 #print Bornology.ofBounded' /-
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/

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

@@ -71,7 +71,7 @@ def Bornology.ofBounded {α : Type _} (B : Set (Set α)) (empty_mem : ∅ ∈ B)
     where
   cobounded :=
     { sets := {s : Set α | sᶜ ∈ B}
-      univ_sets := by rwa [← compl_univ] at empty_mem 
+      univ_sets := by rwa [← compl_univ] at empty_mem
       sets_of_superset := fun x y hx hy => subset_mem (xᶜ) hx (yᶜ) (compl_subset_compl.mpr hy)
       inter_sets := fun x y hx hy => by simpa [compl_inter] using union_mem (xᶜ) hx (yᶜ) hy }
   le_cofinite := by
@@ -94,7 +94,7 @@ def Bornology.ofBounded' {α : Type _} (B : Set (Set α)) (empty_mem : ∅ ∈ B
     Bornology α :=
   Bornology.ofBounded B empty_mem subset_mem union_mem fun x =>
     by
-    rw [sUnion_eq_univ_iff] at sUnion_univ 
+    rw [sUnion_eq_univ_iff] at sUnion_univ
     rcases sUnion_univ x with ⟨s, hs, hxs⟩
     exact subset_mem s hs {x} (singleton_subset_iff.mpr hxs)
 #align bornology.of_bounded' Bornology.ofBounded'
@@ -229,7 +229,7 @@ theorem comap_cobounded_le_iff [Bornology β] {f : α → β} :
     ⟨fun h s hs => _, fun h t ht =>
       ⟨(f '' tᶜ)ᶜ, h <| is_cobounded.compl ht, compl_subset_comm.1 <| subset_preimage_image _ _⟩⟩
   obtain ⟨t, ht, hts⟩ := h hs.compl
-  rw [subset_compl_comm, ← preimage_compl] at hts 
+  rw [subset_compl_comm, ← preimage_compl] at hts
   exact (is_cobounded.compl ht).Subset ((image_subset f hts).trans <| image_preimage_subset _ _)
 #align bornology.comap_cobounded_le_iff Bornology.comap_cobounded_le_iff
 -/

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

@@ -47,8 +47,8 @@ open Set Filter
 variable {ι α β : Type _}
 
 #print Bornology /-
-/- ./././Mathport/Syntax/Translate/Command.lean:404:30: infer kinds are unsupported in Lean 4: #[`cobounded] [] -/
-/- ./././Mathport/Syntax/Translate/Command.lean:404:30: infer kinds are unsupported in Lean 4: #[`le_cofinite] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:400:30: infer kinds are unsupported in Lean 4: #[`cobounded] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:400:30: infer kinds are unsupported in Lean 4: #[`le_cofinite] [] -/
 /-- A **bornology** on a type `α` is a filter of cobounded sets which contains the cofinite filter.
 Such spaces are equivalently specified by their bounded sets, see `bornology.of_bounded`
 and `bornology.ext_iff_is_bounded`-/

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

@@ -47,8 +47,8 @@ open Set Filter
 variable {ι α β : Type _}
 
 #print Bornology /-
-/- ./././Mathport/Syntax/Translate/Command.lean:394:30: infer kinds are unsupported in Lean 4: #[`cobounded] [] -/
-/- ./././Mathport/Syntax/Translate/Command.lean:394:30: infer kinds are unsupported in Lean 4: #[`le_cofinite] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:404:30: infer kinds are unsupported in Lean 4: #[`cobounded] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:404:30: infer kinds are unsupported in Lean 4: #[`le_cofinite] [] -/
 /-- A **bornology** on a type `α` is a filter of cobounded sets which contains the cofinite filter.
 Such spaces are equivalently specified by their bounded sets, see `bornology.of_bounded`
 and `bornology.ext_iff_is_bounded`-/

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

@@ -3,7 +3,7 @@ Copyright (c) 2022 Jireh Loreaux. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jireh Loreaux
 -/
-import Mathbin.Order.Filter.Cofinite
+import Order.Filter.Cofinite
 
 #align_import topology.bornology.basic from "leanprover-community/mathlib"@"a11f9106a169dd302a285019e5165f8ab32ff433"
 
@@ -47,8 +47,8 @@ open Set Filter
 variable {ι α β : Type _}
 
 #print Bornology /-
-/- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`cobounded] [] -/
-/- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`le_cofinite] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:394:30: infer kinds are unsupported in Lean 4: #[`cobounded] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:394:30: infer kinds are unsupported in Lean 4: #[`le_cofinite] [] -/
 /-- A **bornology** on a type `α` is a filter of cobounded sets which contains the cofinite filter.
 Such spaces are equivalently specified by their bounded sets, see `bornology.of_bounded`
 and `bornology.ext_iff_is_bounded`-/
@@ -59,7 +59,7 @@ class Bornology (α : Type _) where
 #align bornology Bornology
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
 #print Bornology.ofBounded /-
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/
@@ -83,7 +83,7 @@ def Bornology.ofBounded {α : Type _} (B : Set (Set α)) (empty_mem : ∅ ∈ B)
 #align bornology.of_bounded Bornology.ofBounded
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
 #print Bornology.ofBounded' /-
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/

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

@@ -351,7 +351,7 @@ def Bornology.cofinite : Bornology α
 #print BoundedSpace /-
 /-- A space with a `bornology` is a **bounded space** if `set.univ : set α` is bounded. -/
 class BoundedSpace (α : Type _) [Bornology α] : Prop where
-  bounded_univ : Bornology.IsBounded (univ : Set α)
+  isBounded_univ : Bornology.IsBounded (univ : Set α)
 #align bounded_space BoundedSpace
 -/
 
@@ -375,7 +375,7 @@ variable [BoundedSpace α]
 
 #print Bornology.IsBounded.all /-
 theorem IsBounded.all (s : Set α) : IsBounded s :=
-  BoundedSpace.bounded_univ.Subset s.subset_univ
+  BoundedSpace.isBounded_univ.Subset s.subset_univ
 #align bornology.is_bounded.all Bornology.IsBounded.all
 -/
 

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

@@ -147,11 +147,11 @@ theorem isCobounded_compl_iff : IsCobounded (sᶜ) ↔ IsBounded s :=
 #align bornology.is_cobounded_compl_iff Bornology.isCobounded_compl_iff
 -/
 
-alias is_bounded_compl_iff ↔ is_bounded.of_compl is_cobounded.compl
+alias ⟨is_bounded.of_compl, is_cobounded.compl⟩ := is_bounded_compl_iff
 #align bornology.is_bounded.of_compl Bornology.IsBounded.of_compl
 #align bornology.is_cobounded.compl Bornology.IsCobounded.compl
 
-alias is_cobounded_compl_iff ↔ is_cobounded.of_compl is_bounded.compl
+alias ⟨is_cobounded.of_compl, is_bounded.compl⟩ := is_cobounded_compl_iff
 #align bornology.is_cobounded.of_compl Bornology.IsCobounded.of_compl
 #align bornology.is_bounded.compl Bornology.IsBounded.compl
 

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

@@ -2,14 +2,11 @@
 Copyright (c) 2022 Jireh Loreaux. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jireh Loreaux
-
-! This file was ported from Lean 3 source module topology.bornology.basic
-! leanprover-community/mathlib commit a11f9106a169dd302a285019e5165f8ab32ff433
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Filter.Cofinite
 
+#align_import topology.bornology.basic from "leanprover-community/mathlib"@"a11f9106a169dd302a285019e5165f8ab32ff433"
+
 /-!
 # Basic theory of bornology
 
@@ -62,7 +59,7 @@ class Bornology (α : Type _) where
 #align bornology Bornology
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
 #print Bornology.ofBounded /-
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/
@@ -86,7 +83,7 @@ def Bornology.ofBounded {α : Type _} (B : Set (Set α)) (empty_mem : ∅ ∈ B)
 #align bornology.of_bounded Bornology.ofBounded
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
 #print Bornology.ofBounded' /-
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/

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

@@ -50,8 +50,8 @@ open Set Filter
 variable {ι α β : Type _}
 
 #print Bornology /-
-/- ./././Mathport/Syntax/Translate/Command.lean:394:30: infer kinds are unsupported in Lean 4: #[`cobounded] [] -/
-/- ./././Mathport/Syntax/Translate/Command.lean:394:30: infer kinds are unsupported in Lean 4: #[`le_cofinite] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`cobounded] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`le_cofinite] [] -/
 /-- A **bornology** on a type `α` is a filter of cobounded sets which contains the cofinite filter.
 Such spaces are equivalently specified by their bounded sets, see `bornology.of_bounded`
 and `bornology.ext_iff_is_bounded`-/
@@ -63,6 +63,7 @@ class Bornology (α : Type _) where
 -/
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
+#print Bornology.ofBounded /-
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/
 @[simps]
@@ -83,8 +84,10 @@ def Bornology.ofBounded {α : Type _} (B : Set (Set α)) (empty_mem : ∅ ∈ B)
     rw [compl_compl]
     exact singleton_mem x
 #align bornology.of_bounded Bornology.ofBounded
+-/
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
+#print Bornology.ofBounded' /-
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/
 @[simps]
@@ -98,6 +101,7 @@ def Bornology.ofBounded' {α : Type _} (B : Set (Set α)) (empty_mem : ∅ ∈ B
     rcases sUnion_univ x with ⟨s, hs, hxs⟩
     exact subset_mem s hs {x} (singleton_subset_iff.mpr hxs)
 #align bornology.of_bounded' Bornology.ofBounded'
+-/
 
 namespace Bornology
 
@@ -126,19 +130,25 @@ theorem isCobounded_def {s : Set α} : IsCobounded s ↔ s ∈ cobounded α :=
 #align bornology.is_cobounded_def Bornology.isCobounded_def
 -/
 
+#print Bornology.isBounded_def /-
 theorem isBounded_def {s : Set α} : IsBounded s ↔ sᶜ ∈ cobounded α :=
   Iff.rfl
 #align bornology.is_bounded_def Bornology.isBounded_def
+-/
 
+#print Bornology.isBounded_compl_iff /-
 @[simp]
 theorem isBounded_compl_iff : IsBounded (sᶜ) ↔ IsCobounded s := by
   rw [is_bounded_def, is_cobounded_def, compl_compl]
 #align bornology.is_bounded_compl_iff Bornology.isBounded_compl_iff
+-/
 
+#print Bornology.isCobounded_compl_iff /-
 @[simp]
 theorem isCobounded_compl_iff : IsCobounded (sᶜ) ↔ IsBounded s :=
   Iff.rfl
 #align bornology.is_cobounded_compl_iff Bornology.isCobounded_compl_iff
+-/
 
 alias is_bounded_compl_iff ↔ is_bounded.of_compl is_cobounded.compl
 #align bornology.is_bounded.of_compl Bornology.IsBounded.of_compl
@@ -169,23 +179,31 @@ theorem isCobounded_univ : IsCobounded (univ : Set α) :=
 #align bornology.is_cobounded_univ Bornology.isCobounded_univ
 -/
 
+#print Bornology.isCobounded_inter /-
 @[simp]
 theorem isCobounded_inter : IsCobounded (s ∩ t) ↔ IsCobounded s ∧ IsCobounded t :=
   inter_mem_iff
 #align bornology.is_cobounded_inter Bornology.isCobounded_inter
+-/
 
+#print Bornology.IsCobounded.inter /-
 theorem IsCobounded.inter (hs : IsCobounded s) (ht : IsCobounded t) : IsCobounded (s ∩ t) :=
   isCobounded_inter.2 ⟨hs, ht⟩
 #align bornology.is_cobounded.inter Bornology.IsCobounded.inter
+-/
 
+#print Bornology.isBounded_union /-
 @[simp]
 theorem isBounded_union : IsBounded (s ∪ t) ↔ IsBounded s ∧ IsBounded t := by
   simp only [← is_cobounded_compl_iff, compl_union, is_cobounded_inter]
 #align bornology.is_bounded_union Bornology.isBounded_union
+-/
 
+#print Bornology.IsBounded.union /-
 theorem IsBounded.union (hs : IsBounded s) (ht : IsBounded t) : IsBounded (s ∪ t) :=
   isBounded_union.2 ⟨hs, ht⟩
 #align bornology.is_bounded.union Bornology.IsBounded.union
+-/
 
 #print Bornology.IsCobounded.superset /-
 theorem IsCobounded.superset (hs : IsCobounded s) (ht : s ⊆ t) : IsCobounded t :=
@@ -206,6 +224,7 @@ theorem sUnion_bounded_univ : ⋃₀ {s : Set α | IsBounded s} = univ :=
 #align bornology.sUnion_bounded_univ Bornology.sUnion_bounded_univ
 -/
 
+#print Bornology.comap_cobounded_le_iff /-
 theorem comap_cobounded_le_iff [Bornology β] {f : α → β} :
     (cobounded β).comap f ≤ cobounded α ↔ ∀ ⦃s⦄, IsBounded s → IsBounded (f '' s) :=
   by
@@ -216,6 +235,7 @@ theorem comap_cobounded_le_iff [Bornology β] {f : α → β} :
   rw [subset_compl_comm, ← preimage_compl] at hts 
   exact (is_cobounded.compl ht).Subset ((image_subset f hts).trans <| image_preimage_subset _ _)
 #align bornology.comap_cobounded_le_iff Bornology.comap_cobounded_le_iff
+-/
 
 end
 
@@ -235,34 +255,44 @@ theorem ext_iff_isBounded {t t' : Bornology α} :
 
 variable {s : Set α}
 
+#print Bornology.isCobounded_ofBounded_iff /-
 theorem isCobounded_ofBounded_iff (B : Set (Set α)) {empty_mem subset_mem union_mem sUnion_univ} :
     @IsCobounded _ (ofBounded B empty_mem subset_mem union_mem sUnion_univ) s ↔ sᶜ ∈ B :=
   Iff.rfl
 #align bornology.is_cobounded_of_bounded_iff Bornology.isCobounded_ofBounded_iff
+-/
 
+#print Bornology.isBounded_ofBounded_iff /-
 theorem isBounded_ofBounded_iff (B : Set (Set α)) {empty_mem subset_mem union_mem sUnion_univ} :
     @IsBounded _ (ofBounded B empty_mem subset_mem union_mem sUnion_univ) s ↔ s ∈ B := by
   rw [is_bounded_def, ← Filter.mem_sets, of_bounded_cobounded_sets, Set.mem_setOf_eq, compl_compl]
 #align bornology.is_bounded_of_bounded_iff Bornology.isBounded_ofBounded_iff
+-/
 
 variable [Bornology α]
 
+#print Bornology.isCobounded_biInter /-
 theorem isCobounded_biInter {s : Set ι} {f : ι → Set α} (hs : s.Finite) :
     IsCobounded (⋂ i ∈ s, f i) ↔ ∀ i ∈ s, IsCobounded (f i) :=
   biInter_mem hs
 #align bornology.is_cobounded_bInter Bornology.isCobounded_biInter
+-/
 
+#print Bornology.isCobounded_biInter_finset /-
 @[simp]
 theorem isCobounded_biInter_finset (s : Finset ι) {f : ι → Set α} :
     IsCobounded (⋂ i ∈ s, f i) ↔ ∀ i ∈ s, IsCobounded (f i) :=
   biInter_finset_mem s
 #align bornology.is_cobounded_bInter_finset Bornology.isCobounded_biInter_finset
+-/
 
+#print Bornology.isCobounded_iInter /-
 @[simp]
 theorem isCobounded_iInter [Finite ι] {f : ι → Set α} :
     IsCobounded (⋂ i, f i) ↔ ∀ i, IsCobounded (f i) :=
   iInter_mem
 #align bornology.is_cobounded_Inter Bornology.isCobounded_iInter
+-/
 
 #print Bornology.isCobounded_sInter /-
 theorem isCobounded_sInter {S : Set (Set α)} (hs : S.Finite) :
@@ -271,15 +301,19 @@ theorem isCobounded_sInter {S : Set (Set α)} (hs : S.Finite) :
 #align bornology.is_cobounded_sInter Bornology.isCobounded_sInter
 -/
 
+#print Bornology.isBounded_biUnion /-
 theorem isBounded_biUnion {s : Set ι} {f : ι → Set α} (hs : s.Finite) :
     IsBounded (⋃ i ∈ s, f i) ↔ ∀ i ∈ s, IsBounded (f i) := by
   simp only [← is_cobounded_compl_iff, compl_Union, is_cobounded_bInter hs]
 #align bornology.is_bounded_bUnion Bornology.isBounded_biUnion
+-/
 
+#print Bornology.isBounded_biUnion_finset /-
 theorem isBounded_biUnion_finset (s : Finset ι) {f : ι → Set α} :
     IsBounded (⋃ i ∈ s, f i) ↔ ∀ i ∈ s, IsBounded (f i) :=
   isBounded_biUnion s.finite_toSet
 #align bornology.is_bounded_bUnion_finset Bornology.isBounded_biUnion_finset
+-/
 
 #print Bornology.isBounded_sUnion /-
 theorem isBounded_sUnion {S : Set (Set α)} (hs : S.Finite) :
@@ -287,10 +321,12 @@ theorem isBounded_sUnion {S : Set (Set α)} (hs : S.Finite) :
 #align bornology.is_bounded_sUnion Bornology.isBounded_sUnion
 -/
 
+#print Bornology.isBounded_iUnion /-
 @[simp]
 theorem isBounded_iUnion [Finite ι] {s : ι → Set α} : IsBounded (⋃ i, s i) ↔ ∀ i, IsBounded (s i) :=
   by rw [← sUnion_range, is_bounded_sUnion (finite_range s), forall_range_iff]
 #align bornology.is_bounded_Union Bornology.isBounded_iUnion
+-/
 
 end Bornology
 
@@ -332,9 +368,11 @@ theorem isBounded_univ : IsBounded (univ : Set α) ↔ BoundedSpace α :=
 #align bornology.is_bounded_univ Bornology.isBounded_univ
 -/
 
+#print Bornology.cobounded_eq_bot_iff /-
 theorem cobounded_eq_bot_iff : cobounded α = ⊥ ↔ BoundedSpace α := by
   rw [← is_bounded_univ, is_bounded_def, compl_univ, empty_mem_iff_bot]
 #align bornology.cobounded_eq_bot_iff Bornology.cobounded_eq_bot_iff
+-/
 
 variable [BoundedSpace α]
 
@@ -352,10 +390,12 @@ theorem IsCobounded.all (s : Set α) : IsCobounded s :=
 
 variable (α)
 
+#print Bornology.cobounded_eq_bot /-
 @[simp]
 theorem cobounded_eq_bot : cobounded α = ⊥ :=
   cobounded_eq_bot_iff.2 ‹_›
 #align bornology.cobounded_eq_bot Bornology.cobounded_eq_bot
+-/
 
 end Bornology
 

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

@@ -62,7 +62,7 @@ class Bornology (α : Type _) where
 #align bornology Bornology
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/
 @[simps]
@@ -84,7 +84,7 @@ def Bornology.ofBounded {α : Type _} (B : Set (Set α)) (empty_mem : ∅ ∈ B)
     exact singleton_mem x
 #align bornology.of_bounded Bornology.ofBounded
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/
 @[simps]

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

@@ -50,8 +50,8 @@ open Set Filter
 variable {ι α β : Type _}
 
 #print Bornology /-
-/- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`cobounded] [] -/
-/- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`le_cofinite] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:394:30: infer kinds are unsupported in Lean 4: #[`cobounded] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:394:30: infer kinds are unsupported in Lean 4: #[`le_cofinite] [] -/
 /-- A **bornology** on a type `α` is a filter of cobounded sets which contains the cofinite filter.
 Such spaces are equivalently specified by their bounded sets, see `bornology.of_bounded`
 and `bornology.ext_iff_is_bounded`-/
@@ -72,7 +72,7 @@ def Bornology.ofBounded {α : Type _} (B : Set (Set α)) (empty_mem : ∅ ∈ B)
     (singleton_mem : ∀ x, {x} ∈ B) : Bornology α
     where
   cobounded :=
-    { sets := { s : Set α | sᶜ ∈ B }
+    { sets := {s : Set α | sᶜ ∈ B}
       univ_sets := by rwa [← compl_univ] at empty_mem 
       sets_of_superset := fun x y hx hy => subset_mem (xᶜ) hx (yᶜ) (compl_subset_compl.mpr hy)
       inter_sets := fun x y hx hy => by simpa [compl_inter] using union_mem (xᶜ) hx (yᶜ) hy }
@@ -201,7 +201,7 @@ theorem IsBounded.subset (ht : IsBounded t) (hs : s ⊆ t) : IsBounded s :=
 
 #print Bornology.sUnion_bounded_univ /-
 @[simp]
-theorem sUnion_bounded_univ : ⋃₀ { s : Set α | IsBounded s } = univ :=
+theorem sUnion_bounded_univ : ⋃₀ {s : Set α | IsBounded s} = univ :=
   sUnion_eq_univ_iff.2 fun a => ⟨{a}, isBounded_singleton, mem_singleton a⟩
 #align bornology.sUnion_bounded_univ Bornology.sUnion_bounded_univ
 -/

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

@@ -73,7 +73,7 @@ def Bornology.ofBounded {α : Type _} (B : Set (Set α)) (empty_mem : ∅ ∈ B)
     where
   cobounded :=
     { sets := { s : Set α | sᶜ ∈ B }
-      univ_sets := by rwa [← compl_univ] at empty_mem
+      univ_sets := by rwa [← compl_univ] at empty_mem 
       sets_of_superset := fun x y hx hy => subset_mem (xᶜ) hx (yᶜ) (compl_subset_compl.mpr hy)
       inter_sets := fun x y hx hy => by simpa [compl_inter] using union_mem (xᶜ) hx (yᶜ) hy }
   le_cofinite := by
@@ -94,7 +94,7 @@ def Bornology.ofBounded' {α : Type _} (B : Set (Set α)) (empty_mem : ∅ ∈ B
     Bornology α :=
   Bornology.ofBounded B empty_mem subset_mem union_mem fun x =>
     by
-    rw [sUnion_eq_univ_iff] at sUnion_univ
+    rw [sUnion_eq_univ_iff] at sUnion_univ 
     rcases sUnion_univ x with ⟨s, hs, hxs⟩
     exact subset_mem s hs {x} (singleton_subset_iff.mpr hxs)
 #align bornology.of_bounded' Bornology.ofBounded'
@@ -213,7 +213,7 @@ theorem comap_cobounded_le_iff [Bornology β] {f : α → β} :
     ⟨fun h s hs => _, fun h t ht =>
       ⟨(f '' tᶜ)ᶜ, h <| is_cobounded.compl ht, compl_subset_comm.1 <| subset_preimage_image _ _⟩⟩
   obtain ⟨t, ht, hts⟩ := h hs.compl
-  rw [subset_compl_comm, ← preimage_compl] at hts
+  rw [subset_compl_comm, ← preimage_compl] at hts 
   exact (is_cobounded.compl ht).Subset ((image_subset f hts).trans <| image_preimage_subset _ _)
 #align bornology.comap_cobounded_le_iff Bornology.comap_cobounded_le_iff
 

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

@@ -62,12 +62,6 @@ class Bornology (α : Type _) where
 #align bornology Bornology
 -/
 
-/- warning: bornology.of_bounded -> Bornology.ofBounded is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (B : Set.{u1} (Set.{u1} α)), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)) B) -> (forall (s₁ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s₂ s₁) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₂ B))) -> (forall (s₁ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₂ B) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s₁ s₂) B))) -> (forall (x : α), Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) x) B) -> (Bornology.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}} (B : Set.{u1} (Set.{u1} α)), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)) B) -> (forall (s₁ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s₂ s₁) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₂ B))) -> (forall (s₁ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₂ B) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s₁ s₂) B))) -> (forall (x : α), Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) x) B) -> (Bornology.{u1} α)
-Case conversion may be inaccurate. Consider using '#align bornology.of_bounded Bornology.ofBoundedₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/
@@ -90,12 +84,6 @@ def Bornology.ofBounded {α : Type _} (B : Set (Set α)) (empty_mem : ∅ ∈ B)
     exact singleton_mem x
 #align bornology.of_bounded Bornology.ofBounded
 
-/- warning: bornology.of_bounded' -> Bornology.ofBounded' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (B : Set.{u1} (Set.{u1} α)), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)) B) -> (forall (s₁ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s₂ s₁) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₂ B))) -> (forall (s₁ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₂ B) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s₁ s₂) B))) -> (Eq.{succ u1} (Set.{u1} α) (Set.sUnion.{u1} α B) (Set.univ.{u1} α)) -> (Bornology.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}} (B : Set.{u1} (Set.{u1} α)), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)) B) -> (forall (s₁ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s₂ s₁) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₂ B))) -> (forall (s₁ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₂ B) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s₁ s₂) B))) -> (Eq.{succ u1} (Set.{u1} α) (Set.sUnion.{u1} α B) (Set.univ.{u1} α)) -> (Bornology.{u1} α)
-Case conversion may be inaccurate. Consider using '#align bornology.of_bounded' Bornology.ofBounded'ₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/
@@ -138,66 +126,24 @@ theorem isCobounded_def {s : Set α} : IsCobounded s ↔ s ∈ cobounded α :=
 #align bornology.is_cobounded_def Bornology.isCobounded_def
 -/
 
-/- warning: bornology.is_bounded_def -> Bornology.isBounded_def is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α}, Iff (Bornology.IsBounded.{u1} α _inst_1 s) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s) (Bornology.cobounded.{u1} α _inst_1))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α}, Iff (Bornology.IsBounded.{u1} α _inst_1 s) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s) (Bornology.cobounded.{u1} α _inst_1))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_def Bornology.isBounded_defₓ'. -/
 theorem isBounded_def {s : Set α} : IsBounded s ↔ sᶜ ∈ cobounded α :=
   Iff.rfl
 #align bornology.is_bounded_def Bornology.isBounded_def
 
-/- warning: bornology.is_bounded_compl_iff -> Bornology.isBounded_compl_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α}, Iff (Bornology.IsBounded.{u1} α _inst_1 (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s)) (Bornology.IsCobounded.{u1} α _inst_1 s)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α}, Iff (Bornology.IsBounded.{u1} α _inst_1 (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s)) (Bornology.IsCobounded.{u1} α _inst_1 s)
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_compl_iff Bornology.isBounded_compl_iffₓ'. -/
 @[simp]
 theorem isBounded_compl_iff : IsBounded (sᶜ) ↔ IsCobounded s := by
   rw [is_bounded_def, is_cobounded_def, compl_compl]
 #align bornology.is_bounded_compl_iff Bornology.isBounded_compl_iff
 
-/- warning: bornology.is_cobounded_compl_iff -> Bornology.isCobounded_compl_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α}, Iff (Bornology.IsCobounded.{u1} α _inst_1 (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s)) (Bornology.IsBounded.{u1} α _inst_1 s)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α}, Iff (Bornology.IsCobounded.{u1} α _inst_1 (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s)) (Bornology.IsBounded.{u1} α _inst_1 s)
-Case conversion may be inaccurate. Consider using '#align bornology.is_cobounded_compl_iff Bornology.isCobounded_compl_iffₓ'. -/
 @[simp]
 theorem isCobounded_compl_iff : IsCobounded (sᶜ) ↔ IsBounded s :=
   Iff.rfl
 #align bornology.is_cobounded_compl_iff Bornology.isCobounded_compl_iff
 
-/- warning: bornology.is_bounded.of_compl -> Bornology.IsBounded.of_compl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α}, (Bornology.IsBounded.{u1} α _inst_1 (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s)) -> (Bornology.IsCobounded.{u1} α _inst_1 s)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α}, (Bornology.IsBounded.{u1} α _inst_1 (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s)) -> (Bornology.IsCobounded.{u1} α _inst_1 s)
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded.of_compl Bornology.IsBounded.of_complₓ'. -/
-/- warning: bornology.is_cobounded.compl -> Bornology.IsCobounded.compl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α}, (Bornology.IsCobounded.{u1} α _inst_1 s) -> (Bornology.IsBounded.{u1} α _inst_1 (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α}, (Bornology.IsCobounded.{u1} α _inst_1 s) -> (Bornology.IsBounded.{u1} α _inst_1 (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s))
-Case conversion may be inaccurate. Consider using '#align bornology.is_cobounded.compl Bornology.IsCobounded.complₓ'. -/
 alias is_bounded_compl_iff ↔ is_bounded.of_compl is_cobounded.compl
 #align bornology.is_bounded.of_compl Bornology.IsBounded.of_compl
 #align bornology.is_cobounded.compl Bornology.IsCobounded.compl
 
-/- warning: bornology.is_cobounded.of_compl -> Bornology.IsCobounded.of_compl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α}, (Bornology.IsCobounded.{u1} α _inst_1 (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s)) -> (Bornology.IsBounded.{u1} α _inst_1 s)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α}, (Bornology.IsCobounded.{u1} α _inst_1 (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s)) -> (Bornology.IsBounded.{u1} α _inst_1 s)
-Case conversion may be inaccurate. Consider using '#align bornology.is_cobounded.of_compl Bornology.IsCobounded.of_complₓ'. -/
-/- warning: bornology.is_bounded.compl -> Bornology.IsBounded.compl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α}, (Bornology.IsBounded.{u1} α _inst_1 s) -> (Bornology.IsCobounded.{u1} α _inst_1 (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α}, (Bornology.IsBounded.{u1} α _inst_1 s) -> (Bornology.IsCobounded.{u1} α _inst_1 (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded.compl Bornology.IsBounded.complₓ'. -/
 alias is_cobounded_compl_iff ↔ is_cobounded.of_compl is_bounded.compl
 #align bornology.is_cobounded.of_compl Bornology.IsCobounded.of_compl
 #align bornology.is_bounded.compl Bornology.IsBounded.compl
@@ -223,44 +169,20 @@ theorem isCobounded_univ : IsCobounded (univ : Set α) :=
 #align bornology.is_cobounded_univ Bornology.isCobounded_univ
 -/
 
-/- warning: bornology.is_cobounded_inter -> Bornology.isCobounded_inter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Bornology.IsCobounded.{u1} α _inst_1 (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t)) (And (Bornology.IsCobounded.{u1} α _inst_1 s) (Bornology.IsCobounded.{u1} α _inst_1 t))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Bornology.IsCobounded.{u1} α _inst_1 (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t)) (And (Bornology.IsCobounded.{u1} α _inst_1 s) (Bornology.IsCobounded.{u1} α _inst_1 t))
-Case conversion may be inaccurate. Consider using '#align bornology.is_cobounded_inter Bornology.isCobounded_interₓ'. -/
 @[simp]
 theorem isCobounded_inter : IsCobounded (s ∩ t) ↔ IsCobounded s ∧ IsCobounded t :=
   inter_mem_iff
 #align bornology.is_cobounded_inter Bornology.isCobounded_inter
 
-/- warning: bornology.is_cobounded.inter -> Bornology.IsCobounded.inter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α}, (Bornology.IsCobounded.{u1} α _inst_1 s) -> (Bornology.IsCobounded.{u1} α _inst_1 t) -> (Bornology.IsCobounded.{u1} α _inst_1 (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α}, (Bornology.IsCobounded.{u1} α _inst_1 s) -> (Bornology.IsCobounded.{u1} α _inst_1 t) -> (Bornology.IsCobounded.{u1} α _inst_1 (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t))
-Case conversion may be inaccurate. Consider using '#align bornology.is_cobounded.inter Bornology.IsCobounded.interₓ'. -/
 theorem IsCobounded.inter (hs : IsCobounded s) (ht : IsCobounded t) : IsCobounded (s ∩ t) :=
   isCobounded_inter.2 ⟨hs, ht⟩
 #align bornology.is_cobounded.inter Bornology.IsCobounded.inter
 
-/- warning: bornology.is_bounded_union -> Bornology.isBounded_union is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Bornology.IsBounded.{u1} α _inst_1 (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s t)) (And (Bornology.IsBounded.{u1} α _inst_1 s) (Bornology.IsBounded.{u1} α _inst_1 t))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Bornology.IsBounded.{u1} α _inst_1 (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s t)) (And (Bornology.IsBounded.{u1} α _inst_1 s) (Bornology.IsBounded.{u1} α _inst_1 t))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_union Bornology.isBounded_unionₓ'. -/
 @[simp]
 theorem isBounded_union : IsBounded (s ∪ t) ↔ IsBounded s ∧ IsBounded t := by
   simp only [← is_cobounded_compl_iff, compl_union, is_cobounded_inter]
 #align bornology.is_bounded_union Bornology.isBounded_union
 
-/- warning: bornology.is_bounded.union -> Bornology.IsBounded.union is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α}, (Bornology.IsBounded.{u1} α _inst_1 s) -> (Bornology.IsBounded.{u1} α _inst_1 t) -> (Bornology.IsBounded.{u1} α _inst_1 (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s t))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α}, (Bornology.IsBounded.{u1} α _inst_1 s) -> (Bornology.IsBounded.{u1} α _inst_1 t) -> (Bornology.IsBounded.{u1} α _inst_1 (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s t))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded.union Bornology.IsBounded.unionₓ'. -/
 theorem IsBounded.union (hs : IsBounded s) (ht : IsBounded t) : IsBounded (s ∪ t) :=
   isBounded_union.2 ⟨hs, ht⟩
 #align bornology.is_bounded.union Bornology.IsBounded.union
@@ -284,12 +206,6 @@ theorem sUnion_bounded_univ : ⋃₀ { s : Set α | IsBounded s } = univ :=
 #align bornology.sUnion_bounded_univ Bornology.sUnion_bounded_univ
 -/
 
-/- warning: bornology.comap_cobounded_le_iff -> Bornology.comap_cobounded_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Bornology.{u1} α] [_inst_2 : Bornology.{u2} β] {f : α -> β}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.comap.{u1, u2} α β f (Bornology.cobounded.{u2} β _inst_2)) (Bornology.cobounded.{u1} α _inst_1)) (forall {{s : Set.{u1} α}}, (Bornology.IsBounded.{u1} α _inst_1 s) -> (Bornology.IsBounded.{u2} β _inst_2 (Set.image.{u1, u2} α β f s)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Bornology.{u1} α] [_inst_2 : Bornology.{u2} β] {f : α -> β}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.comap.{u1, u2} α β f (Bornology.cobounded.{u2} β _inst_2)) (Bornology.cobounded.{u1} α _inst_1)) (forall {{s : Set.{u1} α}}, (Bornology.IsBounded.{u1} α _inst_1 s) -> (Bornology.IsBounded.{u2} β _inst_2 (Set.image.{u1, u2} α β f s)))
-Case conversion may be inaccurate. Consider using '#align bornology.comap_cobounded_le_iff Bornology.comap_cobounded_le_iffₓ'. -/
 theorem comap_cobounded_le_iff [Bornology β] {f : α → β} :
     (cobounded β).comap f ≤ cobounded α ↔ ∀ ⦃s⦄, IsBounded s → IsBounded (f '' s) :=
   by
@@ -319,23 +235,11 @@ theorem ext_iff_isBounded {t t' : Bornology α} :
 
 variable {s : Set α}
 
-/- warning: bornology.is_cobounded_of_bounded_iff -> Bornology.isCobounded_ofBounded_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} (B : Set.{u1} (Set.{u1} α)) {empty_mem : Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)) B} {subset_mem : forall (s₁ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s₂ s₁) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₂ B))} {union_mem : forall (s₁ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₂ B) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s₁ s₂) B))} {sUnion_univ : forall (x : α), Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) x) B}, Iff (Bornology.IsCobounded.{u1} α (Bornology.ofBounded.{u1} α B empty_mem subset_mem union_mem sUnion_univ) s) (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s) B)
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} (B : Set.{u1} (Set.{u1} α)) {empty_mem : Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)) B} {subset_mem : forall (s₁ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s₂ s₁) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₂ B))} {union_mem : forall (s₁ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₂ B) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s₁ s₂) B))} {sUnion_univ : forall (x : α), Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) x) B}, Iff (Bornology.IsCobounded.{u1} α (Bornology.ofBounded.{u1} α B empty_mem subset_mem union_mem sUnion_univ) s) (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s) B)
-Case conversion may be inaccurate. Consider using '#align bornology.is_cobounded_of_bounded_iff Bornology.isCobounded_ofBounded_iffₓ'. -/
 theorem isCobounded_ofBounded_iff (B : Set (Set α)) {empty_mem subset_mem union_mem sUnion_univ} :
     @IsCobounded _ (ofBounded B empty_mem subset_mem union_mem sUnion_univ) s ↔ sᶜ ∈ B :=
   Iff.rfl
 #align bornology.is_cobounded_of_bounded_iff Bornology.isCobounded_ofBounded_iff
 
-/- warning: bornology.is_bounded_of_bounded_iff -> Bornology.isBounded_ofBounded_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} (B : Set.{u1} (Set.{u1} α)) {empty_mem : Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)) B} {subset_mem : forall (s₁ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s₂ s₁) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₂ B))} {union_mem : forall (s₁ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₂ B) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s₁ s₂) B))} {sUnion_univ : forall (x : α), Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) x) B}, Iff (Bornology.IsBounded.{u1} α (Bornology.ofBounded.{u1} α B empty_mem subset_mem union_mem sUnion_univ) s) (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s B)
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} (B : Set.{u1} (Set.{u1} α)) {empty_mem : Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)) B} {subset_mem : forall (s₁ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s₂ s₁) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₂ B))} {union_mem : forall (s₁ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₂ B) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s₁ s₂) B))} {sUnion_univ : forall (x : α), Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) x) B}, Iff (Bornology.IsBounded.{u1} α (Bornology.ofBounded.{u1} α B empty_mem subset_mem union_mem sUnion_univ) s) (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s B)
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_of_bounded_iff Bornology.isBounded_ofBounded_iffₓ'. -/
 theorem isBounded_ofBounded_iff (B : Set (Set α)) {empty_mem subset_mem union_mem sUnion_univ} :
     @IsBounded _ (ofBounded B empty_mem subset_mem union_mem sUnion_univ) s ↔ s ∈ B := by
   rw [is_bounded_def, ← Filter.mem_sets, of_bounded_cobounded_sets, Set.mem_setOf_eq, compl_compl]
@@ -343,35 +247,17 @@ theorem isBounded_ofBounded_iff (B : Set (Set α)) {empty_mem subset_mem union_m
 
 variable [Bornology α]
 
-/- warning: bornology.is_cobounded_bInter -> Bornology.isCobounded_biInter is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] {s : Set.{u1} ι} {f : ι -> (Set.{u2} α)}, (Set.Finite.{u1} ι s) -> (Iff (Bornology.IsCobounded.{u2} α _inst_1 (Set.iInter.{u2, succ u1} α ι (fun (i : ι) => Set.iInter.{u2, 0} α (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) (fun (H : Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) => f i)))) (forall (i : ι), (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) -> (Bornology.IsCobounded.{u2} α _inst_1 (f i))))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u2} ι} {f : ι -> (Set.{u1} α)}, (Set.Finite.{u2} ι s) -> (Iff (Bornology.IsCobounded.{u1} α _inst_1 (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => Set.iInter.{u1, 0} α (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) => f i)))) (forall (i : ι), (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) -> (Bornology.IsCobounded.{u1} α _inst_1 (f i))))
-Case conversion may be inaccurate. Consider using '#align bornology.is_cobounded_bInter Bornology.isCobounded_biInterₓ'. -/
 theorem isCobounded_biInter {s : Set ι} {f : ι → Set α} (hs : s.Finite) :
     IsCobounded (⋂ i ∈ s, f i) ↔ ∀ i ∈ s, IsCobounded (f i) :=
   biInter_mem hs
 #align bornology.is_cobounded_bInter Bornology.isCobounded_biInter
 
-/- warning: bornology.is_cobounded_bInter_finset -> Bornology.isCobounded_biInter_finset is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] (s : Finset.{u1} ι) {f : ι -> (Set.{u2} α)}, Iff (Bornology.IsCobounded.{u2} α _inst_1 (Set.iInter.{u2, succ u1} α ι (fun (i : ι) => Set.iInter.{u2, 0} α (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) (fun (H : Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) => f i)))) (forall (i : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) -> (Bornology.IsCobounded.{u2} α _inst_1 (f i)))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] (s : Finset.{u2} ι) {f : ι -> (Set.{u1} α)}, Iff (Bornology.IsCobounded.{u1} α _inst_1 (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => Set.iInter.{u1, 0} α (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) => f i)))) (forall (i : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) -> (Bornology.IsCobounded.{u1} α _inst_1 (f i)))
-Case conversion may be inaccurate. Consider using '#align bornology.is_cobounded_bInter_finset Bornology.isCobounded_biInter_finsetₓ'. -/
 @[simp]
 theorem isCobounded_biInter_finset (s : Finset ι) {f : ι → Set α} :
     IsCobounded (⋂ i ∈ s, f i) ↔ ∀ i ∈ s, IsCobounded (f i) :=
   biInter_finset_mem s
 #align bornology.is_cobounded_bInter_finset Bornology.isCobounded_biInter_finset
 
-/- warning: bornology.is_cobounded_Inter -> Bornology.isCobounded_iInter is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] [_inst_2 : Finite.{succ u1} ι] {f : ι -> (Set.{u2} α)}, Iff (Bornology.IsCobounded.{u2} α _inst_1 (Set.iInter.{u2, succ u1} α ι (fun (i : ι) => f i))) (forall (i : ι), Bornology.IsCobounded.{u2} α _inst_1 (f i))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] [_inst_2 : Finite.{succ u2} ι] {f : ι -> (Set.{u1} α)}, Iff (Bornology.IsCobounded.{u1} α _inst_1 (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => f i))) (forall (i : ι), Bornology.IsCobounded.{u1} α _inst_1 (f i))
-Case conversion may be inaccurate. Consider using '#align bornology.is_cobounded_Inter Bornology.isCobounded_iInterₓ'. -/
 @[simp]
 theorem isCobounded_iInter [Finite ι] {f : ι → Set α} :
     IsCobounded (⋂ i, f i) ↔ ∀ i, IsCobounded (f i) :=
@@ -385,23 +271,11 @@ theorem isCobounded_sInter {S : Set (Set α)} (hs : S.Finite) :
 #align bornology.is_cobounded_sInter Bornology.isCobounded_sInter
 -/
 
-/- warning: bornology.is_bounded_bUnion -> Bornology.isBounded_biUnion is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] {s : Set.{u1} ι} {f : ι -> (Set.{u2} α)}, (Set.Finite.{u1} ι s) -> (Iff (Bornology.IsBounded.{u2} α _inst_1 (Set.iUnion.{u2, succ u1} α ι (fun (i : ι) => Set.iUnion.{u2, 0} α (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) (fun (H : Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) => f i)))) (forall (i : ι), (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) -> (Bornology.IsBounded.{u2} α _inst_1 (f i))))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u2} ι} {f : ι -> (Set.{u1} α)}, (Set.Finite.{u2} ι s) -> (Iff (Bornology.IsBounded.{u1} α _inst_1 (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Set.iUnion.{u1, 0} α (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) => f i)))) (forall (i : ι), (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) -> (Bornology.IsBounded.{u1} α _inst_1 (f i))))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_bUnion Bornology.isBounded_biUnionₓ'. -/
 theorem isBounded_biUnion {s : Set ι} {f : ι → Set α} (hs : s.Finite) :
     IsBounded (⋃ i ∈ s, f i) ↔ ∀ i ∈ s, IsBounded (f i) := by
   simp only [← is_cobounded_compl_iff, compl_Union, is_cobounded_bInter hs]
 #align bornology.is_bounded_bUnion Bornology.isBounded_biUnion
 
-/- warning: bornology.is_bounded_bUnion_finset -> Bornology.isBounded_biUnion_finset is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] (s : Finset.{u1} ι) {f : ι -> (Set.{u2} α)}, Iff (Bornology.IsBounded.{u2} α _inst_1 (Set.iUnion.{u2, succ u1} α ι (fun (i : ι) => Set.iUnion.{u2, 0} α (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) (fun (H : Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) => f i)))) (forall (i : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) -> (Bornology.IsBounded.{u2} α _inst_1 (f i)))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] (s : Finset.{u2} ι) {f : ι -> (Set.{u1} α)}, Iff (Bornology.IsBounded.{u1} α _inst_1 (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Set.iUnion.{u1, 0} α (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) => f i)))) (forall (i : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) -> (Bornology.IsBounded.{u1} α _inst_1 (f i)))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_bUnion_finset Bornology.isBounded_biUnion_finsetₓ'. -/
 theorem isBounded_biUnion_finset (s : Finset ι) {f : ι → Set α} :
     IsBounded (⋃ i ∈ s, f i) ↔ ∀ i ∈ s, IsBounded (f i) :=
   isBounded_biUnion s.finite_toSet
@@ -413,12 +287,6 @@ theorem isBounded_sUnion {S : Set (Set α)} (hs : S.Finite) :
 #align bornology.is_bounded_sUnion Bornology.isBounded_sUnion
 -/
 
-/- warning: bornology.is_bounded_Union -> Bornology.isBounded_iUnion is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] [_inst_2 : Finite.{succ u1} ι] {s : ι -> (Set.{u2} α)}, Iff (Bornology.IsBounded.{u2} α _inst_1 (Set.iUnion.{u2, succ u1} α ι (fun (i : ι) => s i))) (forall (i : ι), Bornology.IsBounded.{u2} α _inst_1 (s i))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] [_inst_2 : Finite.{succ u2} ι] {s : ι -> (Set.{u1} α)}, Iff (Bornology.IsBounded.{u1} α _inst_1 (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => s i))) (forall (i : ι), Bornology.IsBounded.{u1} α _inst_1 (s i))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_Union Bornology.isBounded_iUnionₓ'. -/
 @[simp]
 theorem isBounded_iUnion [Finite ι] {s : ι → Set α} : IsBounded (⋃ i, s i) ↔ ∀ i, IsBounded (s i) :=
   by rw [← sUnion_range, is_bounded_sUnion (finite_range s), forall_range_iff]
@@ -464,12 +332,6 @@ theorem isBounded_univ : IsBounded (univ : Set α) ↔ BoundedSpace α :=
 #align bornology.is_bounded_univ Bornology.isBounded_univ
 -/
 
-/- warning: bornology.cobounded_eq_bot_iff -> Bornology.cobounded_eq_bot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α], Iff (Eq.{succ u1} (Filter.{u1} α) (Bornology.cobounded.{u1} α _inst_1) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (BoundedSpace.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Bornology.{u1} α], Iff (Eq.{succ u1} (Filter.{u1} α) (Bornology.cobounded.{u1} α _inst_1) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (BoundedSpace.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align bornology.cobounded_eq_bot_iff Bornology.cobounded_eq_bot_iffₓ'. -/
 theorem cobounded_eq_bot_iff : cobounded α = ⊥ ↔ BoundedSpace α := by
   rw [← is_bounded_univ, is_bounded_def, compl_univ, empty_mem_iff_bot]
 #align bornology.cobounded_eq_bot_iff Bornology.cobounded_eq_bot_iff
@@ -490,12 +352,6 @@ theorem IsCobounded.all (s : Set α) : IsCobounded s :=
 
 variable (α)
 
-/- warning: bornology.cobounded_eq_bot -> Bornology.cobounded_eq_bot is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : Bornology.{u1} α] [_inst_2 : BoundedSpace.{u1} α _inst_1], Eq.{succ u1} (Filter.{u1} α) (Bornology.cobounded.{u1} α _inst_1) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : Bornology.{u1} α] [_inst_2 : BoundedSpace.{u1} α _inst_1], Eq.{succ u1} (Filter.{u1} α) (Bornology.cobounded.{u1} α _inst_1) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align bornology.cobounded_eq_bot Bornology.cobounded_eq_botₓ'. -/
 @[simp]
 theorem cobounded_eq_bot : cobounded α = ⊥ :=
   cobounded_eq_bot_iff.2 ‹_›

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

@@ -204,18 +204,14 @@ alias is_cobounded_compl_iff ↔ is_cobounded.of_compl is_bounded.compl
 
 #print Bornology.isBounded_empty /-
 @[simp]
-theorem isBounded_empty : IsBounded (∅ : Set α) :=
-  by
-  rw [is_bounded_def, compl_empty]
+theorem isBounded_empty : IsBounded (∅ : Set α) := by rw [is_bounded_def, compl_empty];
   exact univ_mem
 #align bornology.is_bounded_empty Bornology.isBounded_empty
 -/
 
 #print Bornology.isBounded_singleton /-
 @[simp]
-theorem isBounded_singleton : IsBounded ({x} : Set α) :=
-  by
-  rw [is_bounded_def]
+theorem isBounded_singleton : IsBounded ({x} : Set α) := by rw [is_bounded_def];
   exact le_cofinite _ (finite_singleton x).compl_mem_cofinite
 #align bornology.is_bounded_singleton Bornology.isBounded_singleton
 -/
@@ -317,9 +313,7 @@ theorem ext_iff' {t t' : Bornology α} :
 #print Bornology.ext_iff_isBounded /-
 theorem ext_iff_isBounded {t t' : Bornology α} :
     t = t' ↔ ∀ s, @IsBounded α t s ↔ @IsBounded α t' s :=
-  ⟨fun h s => h ▸ Iff.rfl, fun h => by
-    ext
-    simpa only [is_bounded_def, compl_compl] using h (sᶜ)⟩
+  ⟨fun h s => h ▸ Iff.rfl, fun h => by ext; simpa only [is_bounded_def, compl_compl] using h (sᶜ)⟩
 #align bornology.ext_iff_is_bounded Bornology.ext_iff_isBounded
 -/
 

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

@@ -290,7 +290,7 @@ theorem sUnion_bounded_univ : ⋃₀ { s : Set α | IsBounded s } = univ :=
 
 /- warning: bornology.comap_cobounded_le_iff -> Bornology.comap_cobounded_le_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Bornology.{u1} α] [_inst_2 : Bornology.{u2} β] {f : α -> β}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.comap.{u1, u2} α β f (Bornology.cobounded.{u2} β _inst_2)) (Bornology.cobounded.{u1} α _inst_1)) (forall {{s : Set.{u1} α}}, (Bornology.IsBounded.{u1} α _inst_1 s) -> (Bornology.IsBounded.{u2} β _inst_2 (Set.image.{u1, u2} α β f s)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Bornology.{u1} α] [_inst_2 : Bornology.{u2} β] {f : α -> β}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.comap.{u1, u2} α β f (Bornology.cobounded.{u2} β _inst_2)) (Bornology.cobounded.{u1} α _inst_1)) (forall {{s : Set.{u1} α}}, (Bornology.IsBounded.{u1} α _inst_1 s) -> (Bornology.IsBounded.{u2} β _inst_2 (Set.image.{u1, u2} α β f s)))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Bornology.{u1} α] [_inst_2 : Bornology.{u2} β] {f : α -> β}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.comap.{u1, u2} α β f (Bornology.cobounded.{u2} β _inst_2)) (Bornology.cobounded.{u1} α _inst_1)) (forall {{s : Set.{u1} α}}, (Bornology.IsBounded.{u1} α _inst_1 s) -> (Bornology.IsBounded.{u2} β _inst_2 (Set.image.{u1, u2} α β f s)))
 Case conversion may be inaccurate. Consider using '#align bornology.comap_cobounded_le_iff Bornology.comap_cobounded_le_iffₓ'. -/

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

@@ -92,9 +92,9 @@ def Bornology.ofBounded {α : Type _} (B : Set (Set α)) (empty_mem : ∅ ∈ B)
 
 /- warning: bornology.of_bounded' -> Bornology.ofBounded' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} (B : Set.{u1} (Set.{u1} α)), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)) B) -> (forall (s₁ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s₂ s₁) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₂ B))) -> (forall (s₁ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₂ B) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s₁ s₂) B))) -> (Eq.{succ u1} (Set.{u1} α) (Set.unionₛ.{u1} α B) (Set.univ.{u1} α)) -> (Bornology.{u1} α)
+  forall {α : Type.{u1}} (B : Set.{u1} (Set.{u1} α)), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)) B) -> (forall (s₁ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s₂ s₁) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₂ B))) -> (forall (s₁ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s₂ B) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s₁ s₂) B))) -> (Eq.{succ u1} (Set.{u1} α) (Set.sUnion.{u1} α B) (Set.univ.{u1} α)) -> (Bornology.{u1} α)
 but is expected to have type
-  forall {α : Type.{u1}} (B : Set.{u1} (Set.{u1} α)), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)) B) -> (forall (s₁ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s₂ s₁) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₂ B))) -> (forall (s₁ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₂ B) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s₁ s₂) B))) -> (Eq.{succ u1} (Set.{u1} α) (Set.unionₛ.{u1} α B) (Set.univ.{u1} α)) -> (Bornology.{u1} α)
+  forall {α : Type.{u1}} (B : Set.{u1} (Set.{u1} α)), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)) B) -> (forall (s₁ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s₂ s₁) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₂ B))) -> (forall (s₁ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₂ B) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s₁ s₂) B))) -> (Eq.{succ u1} (Set.{u1} α) (Set.sUnion.{u1} α B) (Set.univ.{u1} α)) -> (Bornology.{u1} α)
 Case conversion may be inaccurate. Consider using '#align bornology.of_bounded' Bornology.ofBounded'ₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
 /-- A constructor for bornologies by specifying the bounded sets,
@@ -281,11 +281,11 @@ theorem IsBounded.subset (ht : IsBounded t) (hs : s ⊆ t) : IsBounded s :=
 #align bornology.is_bounded.subset Bornology.IsBounded.subset
 -/
 
-#print Bornology.unionₛ_bounded_univ /-
+#print Bornology.sUnion_bounded_univ /-
 @[simp]
-theorem unionₛ_bounded_univ : ⋃₀ { s : Set α | IsBounded s } = univ :=
-  unionₛ_eq_univ_iff.2 fun a => ⟨{a}, isBounded_singleton, mem_singleton a⟩
-#align bornology.sUnion_bounded_univ Bornology.unionₛ_bounded_univ
+theorem sUnion_bounded_univ : ⋃₀ { s : Set α | IsBounded s } = univ :=
+  sUnion_eq_univ_iff.2 fun a => ⟨{a}, isBounded_singleton, mem_singleton a⟩
+#align bornology.sUnion_bounded_univ Bornology.sUnion_bounded_univ
 -/
 
 /- warning: bornology.comap_cobounded_le_iff -> Bornology.comap_cobounded_le_iff is a dubious translation:
@@ -349,86 +349,86 @@ theorem isBounded_ofBounded_iff (B : Set (Set α)) {empty_mem subset_mem union_m
 
 variable [Bornology α]
 
-/- warning: bornology.is_cobounded_bInter -> Bornology.isCobounded_binterᵢ is a dubious translation:
+/- warning: bornology.is_cobounded_bInter -> Bornology.isCobounded_biInter is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] {s : Set.{u1} ι} {f : ι -> (Set.{u2} α)}, (Set.Finite.{u1} ι s) -> (Iff (Bornology.IsCobounded.{u2} α _inst_1 (Set.interᵢ.{u2, succ u1} α ι (fun (i : ι) => Set.interᵢ.{u2, 0} α (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) (fun (H : Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) => f i)))) (forall (i : ι), (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) -> (Bornology.IsCobounded.{u2} α _inst_1 (f i))))
+  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] {s : Set.{u1} ι} {f : ι -> (Set.{u2} α)}, (Set.Finite.{u1} ι s) -> (Iff (Bornology.IsCobounded.{u2} α _inst_1 (Set.iInter.{u2, succ u1} α ι (fun (i : ι) => Set.iInter.{u2, 0} α (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) (fun (H : Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) => f i)))) (forall (i : ι), (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) -> (Bornology.IsCobounded.{u2} α _inst_1 (f i))))
 but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u2} ι} {f : ι -> (Set.{u1} α)}, (Set.Finite.{u2} ι s) -> (Iff (Bornology.IsCobounded.{u1} α _inst_1 (Set.interᵢ.{u1, succ u2} α ι (fun (i : ι) => Set.interᵢ.{u1, 0} α (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) => f i)))) (forall (i : ι), (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) -> (Bornology.IsCobounded.{u1} α _inst_1 (f i))))
-Case conversion may be inaccurate. Consider using '#align bornology.is_cobounded_bInter Bornology.isCobounded_binterᵢₓ'. -/
-theorem isCobounded_binterᵢ {s : Set ι} {f : ι → Set α} (hs : s.Finite) :
+  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u2} ι} {f : ι -> (Set.{u1} α)}, (Set.Finite.{u2} ι s) -> (Iff (Bornology.IsCobounded.{u1} α _inst_1 (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => Set.iInter.{u1, 0} α (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) => f i)))) (forall (i : ι), (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) -> (Bornology.IsCobounded.{u1} α _inst_1 (f i))))
+Case conversion may be inaccurate. Consider using '#align bornology.is_cobounded_bInter Bornology.isCobounded_biInterₓ'. -/
+theorem isCobounded_biInter {s : Set ι} {f : ι → Set α} (hs : s.Finite) :
     IsCobounded (⋂ i ∈ s, f i) ↔ ∀ i ∈ s, IsCobounded (f i) :=
-  binterᵢ_mem hs
-#align bornology.is_cobounded_bInter Bornology.isCobounded_binterᵢ
+  biInter_mem hs
+#align bornology.is_cobounded_bInter Bornology.isCobounded_biInter
 
-/- warning: bornology.is_cobounded_bInter_finset -> Bornology.isCobounded_binterᵢ_finset is a dubious translation:
+/- warning: bornology.is_cobounded_bInter_finset -> Bornology.isCobounded_biInter_finset is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] (s : Finset.{u1} ι) {f : ι -> (Set.{u2} α)}, Iff (Bornology.IsCobounded.{u2} α _inst_1 (Set.interᵢ.{u2, succ u1} α ι (fun (i : ι) => Set.interᵢ.{u2, 0} α (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) (fun (H : Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) => f i)))) (forall (i : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) -> (Bornology.IsCobounded.{u2} α _inst_1 (f i)))
+  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] (s : Finset.{u1} ι) {f : ι -> (Set.{u2} α)}, Iff (Bornology.IsCobounded.{u2} α _inst_1 (Set.iInter.{u2, succ u1} α ι (fun (i : ι) => Set.iInter.{u2, 0} α (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) (fun (H : Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) => f i)))) (forall (i : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) -> (Bornology.IsCobounded.{u2} α _inst_1 (f i)))
 but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] (s : Finset.{u2} ι) {f : ι -> (Set.{u1} α)}, Iff (Bornology.IsCobounded.{u1} α _inst_1 (Set.interᵢ.{u1, succ u2} α ι (fun (i : ι) => Set.interᵢ.{u1, 0} α (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) => f i)))) (forall (i : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) -> (Bornology.IsCobounded.{u1} α _inst_1 (f i)))
-Case conversion may be inaccurate. Consider using '#align bornology.is_cobounded_bInter_finset Bornology.isCobounded_binterᵢ_finsetₓ'. -/
+  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] (s : Finset.{u2} ι) {f : ι -> (Set.{u1} α)}, Iff (Bornology.IsCobounded.{u1} α _inst_1 (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => Set.iInter.{u1, 0} α (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) => f i)))) (forall (i : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) -> (Bornology.IsCobounded.{u1} α _inst_1 (f i)))
+Case conversion may be inaccurate. Consider using '#align bornology.is_cobounded_bInter_finset Bornology.isCobounded_biInter_finsetₓ'. -/
 @[simp]
-theorem isCobounded_binterᵢ_finset (s : Finset ι) {f : ι → Set α} :
+theorem isCobounded_biInter_finset (s : Finset ι) {f : ι → Set α} :
     IsCobounded (⋂ i ∈ s, f i) ↔ ∀ i ∈ s, IsCobounded (f i) :=
-  binterᵢ_finset_mem s
-#align bornology.is_cobounded_bInter_finset Bornology.isCobounded_binterᵢ_finset
+  biInter_finset_mem s
+#align bornology.is_cobounded_bInter_finset Bornology.isCobounded_biInter_finset
 
-/- warning: bornology.is_cobounded_Inter -> Bornology.isCobounded_interᵢ is a dubious translation:
+/- warning: bornology.is_cobounded_Inter -> Bornology.isCobounded_iInter is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] [_inst_2 : Finite.{succ u1} ι] {f : ι -> (Set.{u2} α)}, Iff (Bornology.IsCobounded.{u2} α _inst_1 (Set.interᵢ.{u2, succ u1} α ι (fun (i : ι) => f i))) (forall (i : ι), Bornology.IsCobounded.{u2} α _inst_1 (f i))
+  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] [_inst_2 : Finite.{succ u1} ι] {f : ι -> (Set.{u2} α)}, Iff (Bornology.IsCobounded.{u2} α _inst_1 (Set.iInter.{u2, succ u1} α ι (fun (i : ι) => f i))) (forall (i : ι), Bornology.IsCobounded.{u2} α _inst_1 (f i))
 but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] [_inst_2 : Finite.{succ u2} ι] {f : ι -> (Set.{u1} α)}, Iff (Bornology.IsCobounded.{u1} α _inst_1 (Set.interᵢ.{u1, succ u2} α ι (fun (i : ι) => f i))) (forall (i : ι), Bornology.IsCobounded.{u1} α _inst_1 (f i))
-Case conversion may be inaccurate. Consider using '#align bornology.is_cobounded_Inter Bornology.isCobounded_interᵢₓ'. -/
+  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] [_inst_2 : Finite.{succ u2} ι] {f : ι -> (Set.{u1} α)}, Iff (Bornology.IsCobounded.{u1} α _inst_1 (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => f i))) (forall (i : ι), Bornology.IsCobounded.{u1} α _inst_1 (f i))
+Case conversion may be inaccurate. Consider using '#align bornology.is_cobounded_Inter Bornology.isCobounded_iInterₓ'. -/
 @[simp]
-theorem isCobounded_interᵢ [Finite ι] {f : ι → Set α} :
+theorem isCobounded_iInter [Finite ι] {f : ι → Set α} :
     IsCobounded (⋂ i, f i) ↔ ∀ i, IsCobounded (f i) :=
-  interᵢ_mem
-#align bornology.is_cobounded_Inter Bornology.isCobounded_interᵢ
+  iInter_mem
+#align bornology.is_cobounded_Inter Bornology.isCobounded_iInter
 
-#print Bornology.isCobounded_interₛ /-
-theorem isCobounded_interₛ {S : Set (Set α)} (hs : S.Finite) :
+#print Bornology.isCobounded_sInter /-
+theorem isCobounded_sInter {S : Set (Set α)} (hs : S.Finite) :
     IsCobounded (⋂₀ S) ↔ ∀ s ∈ S, IsCobounded s :=
-  interₛ_mem hs
-#align bornology.is_cobounded_sInter Bornology.isCobounded_interₛ
+  sInter_mem hs
+#align bornology.is_cobounded_sInter Bornology.isCobounded_sInter
 -/
 
-/- warning: bornology.is_bounded_bUnion -> Bornology.isBounded_bunionᵢ is a dubious translation:
+/- warning: bornology.is_bounded_bUnion -> Bornology.isBounded_biUnion is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] {s : Set.{u1} ι} {f : ι -> (Set.{u2} α)}, (Set.Finite.{u1} ι s) -> (Iff (Bornology.IsBounded.{u2} α _inst_1 (Set.unionᵢ.{u2, succ u1} α ι (fun (i : ι) => Set.unionᵢ.{u2, 0} α (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) (fun (H : Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) => f i)))) (forall (i : ι), (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) -> (Bornology.IsBounded.{u2} α _inst_1 (f i))))
+  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] {s : Set.{u1} ι} {f : ι -> (Set.{u2} α)}, (Set.Finite.{u1} ι s) -> (Iff (Bornology.IsBounded.{u2} α _inst_1 (Set.iUnion.{u2, succ u1} α ι (fun (i : ι) => Set.iUnion.{u2, 0} α (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) (fun (H : Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) => f i)))) (forall (i : ι), (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) -> (Bornology.IsBounded.{u2} α _inst_1 (f i))))
 but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u2} ι} {f : ι -> (Set.{u1} α)}, (Set.Finite.{u2} ι s) -> (Iff (Bornology.IsBounded.{u1} α _inst_1 (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Set.unionᵢ.{u1, 0} α (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) => f i)))) (forall (i : ι), (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) -> (Bornology.IsBounded.{u1} α _inst_1 (f i))))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_bUnion Bornology.isBounded_bunionᵢₓ'. -/
-theorem isBounded_bunionᵢ {s : Set ι} {f : ι → Set α} (hs : s.Finite) :
+  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] {s : Set.{u2} ι} {f : ι -> (Set.{u1} α)}, (Set.Finite.{u2} ι s) -> (Iff (Bornology.IsBounded.{u1} α _inst_1 (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Set.iUnion.{u1, 0} α (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) => f i)))) (forall (i : ι), (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) -> (Bornology.IsBounded.{u1} α _inst_1 (f i))))
+Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_bUnion Bornology.isBounded_biUnionₓ'. -/
+theorem isBounded_biUnion {s : Set ι} {f : ι → Set α} (hs : s.Finite) :
     IsBounded (⋃ i ∈ s, f i) ↔ ∀ i ∈ s, IsBounded (f i) := by
   simp only [← is_cobounded_compl_iff, compl_Union, is_cobounded_bInter hs]
-#align bornology.is_bounded_bUnion Bornology.isBounded_bunionᵢ
+#align bornology.is_bounded_bUnion Bornology.isBounded_biUnion
 
-/- warning: bornology.is_bounded_bUnion_finset -> Bornology.isBounded_bunionᵢ_finset is a dubious translation:
+/- warning: bornology.is_bounded_bUnion_finset -> Bornology.isBounded_biUnion_finset is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] (s : Finset.{u1} ι) {f : ι -> (Set.{u2} α)}, Iff (Bornology.IsBounded.{u2} α _inst_1 (Set.unionᵢ.{u2, succ u1} α ι (fun (i : ι) => Set.unionᵢ.{u2, 0} α (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) (fun (H : Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) => f i)))) (forall (i : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) -> (Bornology.IsBounded.{u2} α _inst_1 (f i)))
+  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] (s : Finset.{u1} ι) {f : ι -> (Set.{u2} α)}, Iff (Bornology.IsBounded.{u2} α _inst_1 (Set.iUnion.{u2, succ u1} α ι (fun (i : ι) => Set.iUnion.{u2, 0} α (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) (fun (H : Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) => f i)))) (forall (i : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i s) -> (Bornology.IsBounded.{u2} α _inst_1 (f i)))
 but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] (s : Finset.{u2} ι) {f : ι -> (Set.{u1} α)}, Iff (Bornology.IsBounded.{u1} α _inst_1 (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Set.unionᵢ.{u1, 0} α (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) => f i)))) (forall (i : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) -> (Bornology.IsBounded.{u1} α _inst_1 (f i)))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_bUnion_finset Bornology.isBounded_bunionᵢ_finsetₓ'. -/
-theorem isBounded_bunionᵢ_finset (s : Finset ι) {f : ι → Set α} :
+  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] (s : Finset.{u2} ι) {f : ι -> (Set.{u1} α)}, Iff (Bornology.IsBounded.{u1} α _inst_1 (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Set.iUnion.{u1, 0} α (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) => f i)))) (forall (i : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) -> (Bornology.IsBounded.{u1} α _inst_1 (f i)))
+Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_bUnion_finset Bornology.isBounded_biUnion_finsetₓ'. -/
+theorem isBounded_biUnion_finset (s : Finset ι) {f : ι → Set α} :
     IsBounded (⋃ i ∈ s, f i) ↔ ∀ i ∈ s, IsBounded (f i) :=
-  isBounded_bunionᵢ s.finite_toSet
-#align bornology.is_bounded_bUnion_finset Bornology.isBounded_bunionᵢ_finset
+  isBounded_biUnion s.finite_toSet
+#align bornology.is_bounded_bUnion_finset Bornology.isBounded_biUnion_finset
 
-#print Bornology.isBounded_unionₛ /-
-theorem isBounded_unionₛ {S : Set (Set α)} (hs : S.Finite) :
+#print Bornology.isBounded_sUnion /-
+theorem isBounded_sUnion {S : Set (Set α)} (hs : S.Finite) :
     IsBounded (⋃₀ S) ↔ ∀ s ∈ S, IsBounded s := by rw [sUnion_eq_bUnion, is_bounded_bUnion hs]
-#align bornology.is_bounded_sUnion Bornology.isBounded_unionₛ
+#align bornology.is_bounded_sUnion Bornology.isBounded_sUnion
 -/
 
-/- warning: bornology.is_bounded_Union -> Bornology.isBounded_unionᵢ is a dubious translation:
+/- warning: bornology.is_bounded_Union -> Bornology.isBounded_iUnion is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] [_inst_2 : Finite.{succ u1} ι] {s : ι -> (Set.{u2} α)}, Iff (Bornology.IsBounded.{u2} α _inst_1 (Set.unionᵢ.{u2, succ u1} α ι (fun (i : ι) => s i))) (forall (i : ι), Bornology.IsBounded.{u2} α _inst_1 (s i))
+  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Bornology.{u2} α] [_inst_2 : Finite.{succ u1} ι] {s : ι -> (Set.{u2} α)}, Iff (Bornology.IsBounded.{u2} α _inst_1 (Set.iUnion.{u2, succ u1} α ι (fun (i : ι) => s i))) (forall (i : ι), Bornology.IsBounded.{u2} α _inst_1 (s i))
 but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] [_inst_2 : Finite.{succ u2} ι] {s : ι -> (Set.{u1} α)}, Iff (Bornology.IsBounded.{u1} α _inst_1 (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => s i))) (forall (i : ι), Bornology.IsBounded.{u1} α _inst_1 (s i))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_Union Bornology.isBounded_unionᵢₓ'. -/
+  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Bornology.{u1} α] [_inst_2 : Finite.{succ u2} ι] {s : ι -> (Set.{u1} α)}, Iff (Bornology.IsBounded.{u1} α _inst_1 (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => s i))) (forall (i : ι), Bornology.IsBounded.{u1} α _inst_1 (s i))
+Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_Union Bornology.isBounded_iUnionₓ'. -/
 @[simp]
-theorem isBounded_unionᵢ [Finite ι] {s : ι → Set α} : IsBounded (⋃ i, s i) ↔ ∀ i, IsBounded (s i) :=
+theorem isBounded_iUnion [Finite ι] {s : ι → Set α} : IsBounded (⋃ i, s i) ↔ ∀ i, IsBounded (s i) :=
   by rw [← sUnion_range, is_bounded_sUnion (finite_range s), forall_range_iff]
-#align bornology.is_bounded_Union Bornology.isBounded_unionᵢ
+#align bornology.is_bounded_Union Bornology.isBounded_iUnion
 
 end Bornology
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/09079525fd01b3dda35e96adaa08d2f943e1648c

@@ -50,8 +50,8 @@ open Set Filter
 variable {ι α β : Type _}
 
 #print Bornology /-
-/- ./././Mathport/Syntax/Translate/Command.lean:388:30: infer kinds are unsupported in Lean 4: #[`cobounded] [] -/
-/- ./././Mathport/Syntax/Translate/Command.lean:388:30: infer kinds are unsupported in Lean 4: #[`le_cofinite] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`cobounded] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`le_cofinite] [] -/
 /-- A **bornology** on a type `α` is a filter of cobounded sets which contains the cofinite filter.
 Such spaces are equivalently specified by their bounded sets, see `bornology.of_bounded`
 and `bornology.ext_iff_is_bounded`-/

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

@@ -68,7 +68,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} (B : Set.{u1} (Set.{u1} α)), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)) B) -> (forall (s₁ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s₂ s₁) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₂ B))) -> (forall (s₁ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₂ B) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s₁ s₂) B))) -> (forall (x : α), Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) x) B) -> (Bornology.{u1} α)
 Case conversion may be inaccurate. Consider using '#align bornology.of_bounded Bornology.ofBoundedₓ'. -/
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/
 @[simps]
@@ -96,7 +96,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} (B : Set.{u1} (Set.{u1} α)), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)) B) -> (forall (s₁ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s₂ s₁) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₂ B))) -> (forall (s₁ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₁ B) -> (forall (s₂ : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s₂ B) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s₁ s₂) B))) -> (Eq.{succ u1} (Set.{u1} α) (Set.unionₛ.{u1} α B) (Set.univ.{u1} α)) -> (Bornology.{u1} α)
 Case conversion may be inaccurate. Consider using '#align bornology.of_bounded' Bornology.ofBounded'ₓ'. -/
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (s₁ s₂ «expr ∈ » B) -/
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/
 @[simps]

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

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

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

@@ -297,7 +297,7 @@ theorem isBounded_sUnion {S : Set (Set α)} (hs : S.Finite) :
 
 @[simp]
 theorem isBounded_iUnion [Finite ι] {s : ι → Set α} : IsBounded (⋃ i, s i) ↔ ∀ i, IsBounded (s i) :=
-  by rw [← sUnion_range, isBounded_sUnion (finite_range s), forall_range_iff]
+  by rw [← sUnion_range, isBounded_sUnion (finite_range s), forall_mem_range]
 #align bornology.is_bounded_Union Bornology.isBounded_iUnion
 
 lemma eventually_ne_cobounded (a : α) : ∀ᶠ x in cobounded α, x ≠ a :=

@@ -48,11 +48,11 @@ Such spaces are equivalently specified by their bounded sets, see `Bornology.ofB
 and `Bornology.ext_iff_isBounded`-/
 class Bornology (α : Type*) where
   /-- The filter of cobounded sets in a bornology. This is a field of the structure, but one
-  should always prefer `Bornology.cobounded` because it makes the `α` argument explciit. -/
+  should always prefer `Bornology.cobounded` because it makes the `α` argument explicit. -/
   cobounded' : Filter α
   /-- The cobounded filter in a bornology is smaller than the cofinite filter. This is a field of
   the structure, but one should always prefer `Bornology.le_cofinite` because it makes the `α`
-  argument explciit. -/
+  argument explicit. -/
   le_cofinite' : cobounded' ≤ cofinite
 #align bornology Bornology
 

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

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

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

Other changes

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

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

@@ -94,23 +94,14 @@ def Bornology.ofBounded {α : Type*} (B : Set (Set α))
     (subset_mem : ∀ s₁ ∈ B, ∀ s₂ ⊆ s₁, s₂ ∈ B)
     (union_mem : ∀ s₁ ∈ B, ∀ s₂ ∈ B, s₁ ∪ s₂ ∈ B)
     (singleton_mem : ∀ x, {x} ∈ B) : Bornology α where
-  cobounded' :=
-    { sets := { s : Set α | sᶜ ∈ B }
-      univ_sets := by rwa [← compl_univ] at empty_mem
-      sets_of_superset := fun hx hy => subset_mem _ hx _ (compl_subset_compl.mpr hy)
-      inter_sets := fun hx hy => by simpa [compl_inter] using union_mem _ hx _ hy }
-  le_cofinite' := by
-    rw [le_cofinite_iff_compl_singleton_mem]
-    intro x
-    change {x}ᶜᶜ ∈ B
-    rw [compl_compl]
-    exact singleton_mem x
+  cobounded' := comk (· ∈ B) empty_mem subset_mem union_mem
+  le_cofinite' := by simpa [le_cofinite_iff_compl_singleton_mem]
 #align bornology.of_bounded Bornology.ofBounded
-#align bornology.of_bounded_cobounded_sets Bornology.ofBounded_cobounded_sets
+#align bornology.of_bounded_cobounded_sets Bornology.ofBounded_cobounded
 
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/
-@[simps!]
+@[simps! cobounded]
 def Bornology.ofBounded' {α : Type*} (B : Set (Set α))
     (empty_mem : ∅ ∈ B)
     (subset_mem : ∀ s₁ ∈ B, ∀ s₂ ⊆ s₁, s₂ ∈ B)
@@ -122,24 +113,24 @@ def Bornology.ofBounded' {α : Type*} (B : Set (Set α))
     rcases sUnion_univ x with ⟨s, hs, hxs⟩
     exact subset_mem s hs {x} (singleton_subset_iff.mpr hxs)
 #align bornology.of_bounded' Bornology.ofBounded'
-#align bornology.of_bounded'_cobounded_sets Bornology.ofBounded'_cobounded_sets
+#align bornology.of_bounded'_cobounded_sets Bornology.ofBounded'_cobounded
 namespace Bornology
 
 section
 
-variable [Bornology α] {s t : Set α} {x : α}
-
 /-- `IsCobounded` is the predicate that `s` is in the filter of cobounded sets in the ambient
 bornology on `α` -/
-def IsCobounded (s : Set α) : Prop :=
+def IsCobounded [Bornology α] (s : Set α) : Prop :=
   s ∈ cobounded α
 #align bornology.is_cobounded Bornology.IsCobounded
 
 /-- `IsBounded` is the predicate that `s` is bounded relative to the ambient bornology on `α`. -/
-def IsBounded (s : Set α) : Prop :=
+def IsBounded [Bornology α] (s : Set α) : Prop :=
   IsCobounded sᶜ
 #align bornology.is_bounded Bornology.IsBounded
 
+variable {_ : Bornology α} {s t : Set α} {x : α}
+
 theorem isCobounded_def {s : Set α} : IsCobounded s ↔ s ∈ cobounded α :=
   Iff.rfl
 #align bornology.is_cobounded_def Bornology.isCobounded_def
@@ -263,9 +254,7 @@ theorem isCobounded_ofBounded_iff (B : Set (Set α)) {empty_mem subset_mem union
 
 theorem isBounded_ofBounded_iff (B : Set (Set α)) {empty_mem subset_mem union_mem sUnion_univ} :
     @IsBounded _ (ofBounded B empty_mem subset_mem union_mem sUnion_univ) s ↔ s ∈ B := by
-  rw [@isBounded_def _ (ofBounded B empty_mem subset_mem union_mem sUnion_univ), ← Filter.mem_sets,
-   ofBounded_cobounded_sets, Set.mem_setOf_eq, compl_compl]
--- porting note: again had to use `@isBounded_def _` and feed Lean the instance
+  rw [isBounded_def, ofBounded_cobounded, compl_mem_comk]
 #align bornology.is_bounded_of_bounded_iff Bornology.isBounded_ofBounded_iff
 
 variable [Bornology α]

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

In some rare cases, golf proofs that needed fixing.

@@ -91,10 +91,9 @@ and showing that they satisfy the appropriate conditions. -/
 @[simps]
 def Bornology.ofBounded {α : Type*} (B : Set (Set α))
     (empty_mem : ∅ ∈ B)
-    (subset_mem : ∀ s₁ (_ : s₁ ∈ B) s₂, s₂ ⊆ s₁ → s₂ ∈ B)
-    (union_mem : ∀ s₁ (_ : s₁ ∈ B) s₂ (_ : s₂ ∈ B), s₁ ∪ s₂ ∈ B)
-    (singleton_mem : ∀ x, {x} ∈ B) : Bornology α
-    where
+    (subset_mem : ∀ s₁ ∈ B, ∀ s₂ ⊆ s₁, s₂ ∈ B)
+    (union_mem : ∀ s₁ ∈ B, ∀ s₂ ∈ B, s₁ ∪ s₂ ∈ B)
+    (singleton_mem : ∀ x, {x} ∈ B) : Bornology α where
   cobounded' :=
     { sets := { s : Set α | sᶜ ∈ B }
       univ_sets := by rwa [← compl_univ] at empty_mem
@@ -114,8 +113,8 @@ and showing that they satisfy the appropriate conditions. -/
 @[simps!]
 def Bornology.ofBounded' {α : Type*} (B : Set (Set α))
     (empty_mem : ∅ ∈ B)
-    (subset_mem : ∀ s₁ (_ : s₁ ∈ B) s₂, s₂ ⊆ s₁ → s₂ ∈ B)
-    (union_mem : ∀ s₁ (_ : s₁ ∈ B) s₂ (_ : s₂ ∈ B), s₁ ∪ s₂ ∈ B)
+    (subset_mem : ∀ s₁ ∈ B, ∀ s₂ ⊆ s₁, s₂ ∈ B)
+    (union_mem : ∀ s₁ ∈ B, ∀ s₂ ∈ B, s₁ ∪ s₂ ∈ B)
     (sUnion_univ : ⋃₀ B = univ) :
     Bornology α :=
   Bornology.ofBounded B empty_mem subset_mem union_mem fun x => by

Add Bornology.eventually_ne_cobounded and Filter.Tendsto.eventually_ne_cobounded.

@@ -312,6 +312,9 @@ theorem isBounded_iUnion [Finite ι] {s : ι → Set α} : IsBounded (⋃ i, s i
   by rw [← sUnion_range, isBounded_sUnion (finite_range s), forall_range_iff]
 #align bornology.is_bounded_Union Bornology.isBounded_iUnion
 
+lemma eventually_ne_cobounded (a : α) : ∀ᶠ x in cobounded α, x ≠ a :=
+  le_cofinite_iff_eventually_ne.1 (le_cofinite _) a
+
 end Bornology
 
 open Bornology
@@ -325,6 +328,10 @@ theorem Set.Finite.isBounded [Bornology α] {s : Set α} (hs : s.Finite) : IsBou
   Bornology.le_cofinite α hs.compl_mem_cofinite
 #align set.finite.is_bounded Set.Finite.isBounded
 
+nonrec lemma Filter.Tendsto.eventually_ne_cobounded [Bornology α] {f : β → α} {l : Filter β}
+    (h : Tendsto f l (cobounded α)) (a : α) : ∀ᶠ x in l, f x ≠ a :=
+  h.eventually <| eventually_ne_cobounded a
+
 instance : Bornology PUnit :=
   ⟨⊥, bot_le⟩
 

This was "feat(topology/metric_space): diameter of pointwise zero and addition"

@@ -173,6 +173,12 @@ theorem isBounded_empty : IsBounded (∅ : Set α) := by
   exact univ_mem
 #align bornology.is_bounded_empty Bornology.isBounded_empty
 
+theorem nonempty_of_not_isBounded (h : ¬IsBounded s) : s.Nonempty := by
+  rw [nonempty_iff_ne_empty]
+  rintro rfl
+  exact h isBounded_empty
+#align metric.nonempty_of_unbounded Bornology.nonempty_of_not_isBounded
+
 @[simp]
 theorem isBounded_singleton : IsBounded ({x} : Set α) := by
   rw [isBounded_def]

@@ -335,6 +335,11 @@ class BoundedSpace (α : Type*) [Bornology α] : Prop where
   bounded_univ : Bornology.IsBounded (univ : Set α)
 #align bounded_space BoundedSpace
 
+/-- A finite space is bounded. -/
+instance (priority := 100) BoundedSpace.of_finite {α : Type*} [Bornology α] [Finite α] :
+    BoundedSpace α where
+  bounded_univ := (toFinite _).isBounded
+
 namespace Bornology
 
 variable [Bornology α]

Use Bornology.IsBounded instead.

@@ -179,6 +179,11 @@ theorem isBounded_singleton : IsBounded ({x} : Set α) := by
   exact le_cofinite _ (finite_singleton x).compl_mem_cofinite
 #align bornology.is_bounded_singleton Bornology.isBounded_singleton
 
+theorem isBounded_iff_forall_mem : IsBounded s ↔ ∀ x ∈ s, IsBounded s :=
+  ⟨fun h _ _ ↦ h, fun h ↦ by
+    rcases s.eq_empty_or_nonempty with rfl | ⟨x, hx⟩
+    exacts [isBounded_empty, h x hx]⟩
+
 @[simp]
 theorem isCobounded_univ : IsCobounded (univ : Set α) :=
   univ_mem
@@ -215,6 +220,13 @@ theorem sUnion_bounded_univ : ⋃₀ { s : Set α | IsBounded s } = univ :=
   sUnion_eq_univ_iff.2 fun a => ⟨{a}, isBounded_singleton, mem_singleton a⟩
 #align bornology.sUnion_bounded_univ Bornology.sUnion_bounded_univ
 
+theorem IsBounded.insert (h : IsBounded s) (x : α) : IsBounded (insert x s) :=
+  isBounded_singleton.union h
+
+@[simp]
+theorem isBounded_insert : IsBounded (insert x s) ↔ IsBounded s :=
+  ⟨fun h ↦ h.subset (subset_insert _ _), (.insert · x)⟩
+
 theorem comap_cobounded_le_iff [Bornology β] {f : α → β} :
     (cobounded β).comap f ≤ cobounded α ↔ ∀ ⦃s⦄, IsBounded s → IsBounded (f '' s) := by
   refine'
@@ -228,16 +240,13 @@ theorem comap_cobounded_le_iff [Bornology β] {f : α → β} :
 end
 
 theorem ext_iff' {t t' : Bornology α} :
-    t = t' ↔ ∀ s, (@cobounded α t).sets s ↔ (@cobounded α t').sets s :=
+    t = t' ↔ ∀ s, s ∈ @cobounded α t ↔ s ∈ @cobounded α t' :=
   (Bornology.ext_iff _ _).trans Filter.ext_iff
 #align bornology.ext_iff' Bornology.ext_iff'
 
 theorem ext_iff_isBounded {t t' : Bornology α} :
     t = t' ↔ ∀ s, @IsBounded α t s ↔ @IsBounded α t' s :=
-  ⟨fun h s => h ▸ Iff.rfl, fun h => by
-    ext s
-    simpa [@isBounded_def _ t, isBounded_def, compl_compl] using h sᶜ⟩
--- porting note: Lean 3 could do this without `@isBounded_def _ t`
+  ext_iff'.trans compl_surjective.forall
 #align bornology.ext_iff_is_bounded Bornology.ext_iff_isBounded
 
 variable {s : Set α}
@@ -301,6 +310,11 @@ end Bornology
 
 open Bornology
 
+theorem Filter.HasBasis.disjoint_cobounded_iff [Bornology α] {ι : Sort*} {p : ι → Prop}
+    {s : ι → Set α} {l : Filter α} (h : l.HasBasis p s) :
+    Disjoint l (cobounded α) ↔ ∃ i, p i ∧ IsBounded (s i) :=
+  h.disjoint_iff_left
+
 theorem Set.Finite.isBounded [Bornology α] {s : Set α} (hs : s.Finite) : IsBounded s :=
   Bornology.le_cofinite α hs.compl_mem_cofinite
 #align set.finite.is_bounded Set.Finite.isBounded
@@ -310,8 +324,7 @@ instance : Bornology PUnit :=
 
 /-- The cofinite filter as a bornology -/
 @[reducible]
-def Bornology.cofinite : Bornology α
-    where
+def Bornology.cofinite : Bornology α where
   cobounded' := Filter.cofinite
   le_cofinite' := le_rfl
 #align bornology.cofinite Bornology.cofinite

@@ -64,7 +64,7 @@ initialize new `simps` projections. -/
 def Bornology.cobounded (α : Type*) [Bornology α] : Filter α := Bornology.cobounded'
 #align bornology.cobounded Bornology.cobounded
 
-alias Bornology.cobounded ← Bornology.Simps.cobounded
+alias Bornology.Simps.cobounded := Bornology.cobounded
 
 lemma Bornology.le_cofinite (α : Type*) [Bornology α] : cobounded α ≤ cofinite :=
 Bornology.le_cofinite'
@@ -159,11 +159,11 @@ theorem isCobounded_compl_iff : IsCobounded sᶜ ↔ IsBounded s :=
   Iff.rfl
 #align bornology.is_cobounded_compl_iff Bornology.isCobounded_compl_iff
 
-alias isBounded_compl_iff ↔ IsBounded.of_compl IsCobounded.compl
+alias ⟨IsBounded.of_compl, IsCobounded.compl⟩ := isBounded_compl_iff
 #align bornology.is_bounded.of_compl Bornology.IsBounded.of_compl
 #align bornology.is_cobounded.compl Bornology.IsCobounded.compl
 
-alias isCobounded_compl_iff ↔ IsCobounded.of_compl IsBounded.compl
+alias ⟨IsCobounded.of_compl, IsBounded.compl⟩ := isCobounded_compl_iff
 #align bornology.is_cobounded.of_compl Bornology.IsCobounded.of_compl
 #align bornology.is_bounded.compl Bornology.IsBounded.compl
 

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

This has nice performance benefits.

@@ -41,12 +41,12 @@ it is intended for regular use as a filter on `α`.
 
 open Set Filter
 
-variable {ι α β : Type _}
+variable {ι α β : Type*}
 
 /-- A **bornology** on a type `α` is a filter of cobounded sets which contains the cofinite filter.
 Such spaces are equivalently specified by their bounded sets, see `Bornology.ofBounded`
 and `Bornology.ext_iff_isBounded`-/
-class Bornology (α : Type _) where
+class Bornology (α : Type*) where
   /-- The filter of cobounded sets in a bornology. This is a field of the structure, but one
   should always prefer `Bornology.cobounded` because it makes the `α` argument explciit. -/
   cobounded' : Filter α
@@ -61,12 +61,12 @@ fields explicit, we have to define these separately, prove the `ext` lemmas manu
 initialize new `simps` projections. -/
 
 /-- The filter of cobounded sets in a bornology. -/
-def Bornology.cobounded (α : Type _) [Bornology α] : Filter α := Bornology.cobounded'
+def Bornology.cobounded (α : Type*) [Bornology α] : Filter α := Bornology.cobounded'
 #align bornology.cobounded Bornology.cobounded
 
 alias Bornology.cobounded ← Bornology.Simps.cobounded
 
-lemma Bornology.le_cofinite (α : Type _) [Bornology α] : cobounded α ≤ cofinite :=
+lemma Bornology.le_cofinite (α : Type*) [Bornology α] : cobounded α ≤ cofinite :=
 Bornology.le_cofinite'
 #align bornology.le_cofinite Bornology.le_cofinite
 
@@ -89,7 +89,7 @@ lemma Bornology.ext_iff (t t' : Bornology α) :
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/
 @[simps]
-def Bornology.ofBounded {α : Type _} (B : Set (Set α))
+def Bornology.ofBounded {α : Type*} (B : Set (Set α))
     (empty_mem : ∅ ∈ B)
     (subset_mem : ∀ s₁ (_ : s₁ ∈ B) s₂, s₂ ⊆ s₁ → s₂ ∈ B)
     (union_mem : ∀ s₁ (_ : s₁ ∈ B) s₂ (_ : s₂ ∈ B), s₁ ∪ s₂ ∈ B)
@@ -112,7 +112,7 @@ def Bornology.ofBounded {α : Type _} (B : Set (Set α))
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/
 @[simps!]
-def Bornology.ofBounded' {α : Type _} (B : Set (Set α))
+def Bornology.ofBounded' {α : Type*} (B : Set (Set α))
     (empty_mem : ∅ ∈ B)
     (subset_mem : ∀ s₁ (_ : s₁ ∈ B) s₂, s₂ ⊆ s₁ → s₂ ∈ B)
     (union_mem : ∀ s₁ (_ : s₁ ∈ B) s₂ (_ : s₂ ∈ B), s₁ ∪ s₂ ∈ B)
@@ -317,7 +317,7 @@ def Bornology.cofinite : Bornology α
 #align bornology.cofinite Bornology.cofinite
 
 /-- A space with a `Bornology` is a **bounded space** if `Set.univ : Set α` is bounded. -/
-class BoundedSpace (α : Type _) [Bornology α] : Prop where
+class BoundedSpace (α : Type*) [Bornology α] : Prop where
   /-- The `Set.univ` is bounded. -/
   bounded_univ : Bornology.IsBounded (univ : Set α)
 #align bounded_space BoundedSpace

• depends on: #5966

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

@@ -2,14 +2,11 @@
 Copyright (c) 2022 Jireh Loreaux. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jireh Loreaux
-
-! This file was ported from Lean 3 source module topology.bornology.basic
-! leanprover-community/mathlib commit 8631e2d5ea77f6c13054d9151d82b83069680cb1
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.Filter.Cofinite
 
+#align_import topology.bornology.basic from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
+
 /-!
 # Basic theory of bornology
 

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

@@ -141,7 +141,7 @@ def IsCobounded (s : Set α) : Prop :=
 
 /-- `IsBounded` is the predicate that `s` is bounded relative to the ambient bornology on `α`. -/
 def IsBounded (s : Set α) : Prop :=
-  IsCobounded (sᶜ)
+  IsCobounded sᶜ
 #align bornology.is_bounded Bornology.IsBounded
 
 theorem isCobounded_def {s : Set α} : IsCobounded s ↔ s ∈ cobounded α :=
@@ -153,12 +153,12 @@ theorem isBounded_def {s : Set α} : IsBounded s ↔ sᶜ ∈ cobounded α :=
 #align bornology.is_bounded_def Bornology.isBounded_def
 
 @[simp]
-theorem isBounded_compl_iff : IsBounded (sᶜ) ↔ IsCobounded s := by
+theorem isBounded_compl_iff : IsBounded sᶜ ↔ IsCobounded s := by
   rw [isBounded_def, isCobounded_def, compl_compl]
 #align bornology.is_bounded_compl_iff Bornology.isBounded_compl_iff
 
 @[simp]
-theorem isCobounded_compl_iff : IsCobounded (sᶜ) ↔ IsBounded s :=
+theorem isCobounded_compl_iff : IsCobounded sᶜ ↔ IsBounded s :=
   Iff.rfl
 #align bornology.is_cobounded_compl_iff Bornology.isCobounded_compl_iff
 
@@ -239,7 +239,7 @@ theorem ext_iff_isBounded {t t' : Bornology α} :
     t = t' ↔ ∀ s, @IsBounded α t s ↔ @IsBounded α t' s :=
   ⟨fun h s => h ▸ Iff.rfl, fun h => by
     ext s
-    simpa [@isBounded_def _ t, isBounded_def, compl_compl] using h (sᶜ)⟩
+    simpa [@isBounded_def _ t, isBounded_def, compl_compl] using h sᶜ⟩
 -- porting note: Lean 3 could do this without `@isBounded_def _ t`
 #align bornology.ext_iff_is_bounded Bornology.ext_iff_isBounded
 
@@ -344,7 +344,7 @@ theorem IsBounded.all (s : Set α) : IsBounded s :=
 #align bornology.is_bounded.all Bornology.IsBounded.all
 
 theorem IsCobounded.all (s : Set α) : IsCobounded s :=
-  compl_compl s ▸ IsBounded.all (sᶜ)
+  compl_compl s ▸ IsBounded.all sᶜ
 #align bornology.is_cobounded.all Bornology.IsCobounded.all
 
 variable (α)

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

@@ -31,7 +31,7 @@ cobounded filter is generally referred to as the *filter at infinity*.
 - `Bornology α`: a class consisting of `cobounded : Filter α` and a proof that this filter
   contains the `cofinite` filter.
 - `Bornology.IsCobounded`: the predicate that a set is a member of the `cobounded α` filter. For
-  `s : set α`, one should prefer `Bornology.IsCobounded s` over `s ∈ cobounded α`.
+  `s : Set α`, one should prefer `Bornology.IsCobounded s` over `s ∈ cobounded α`.
 - `bornology.IsBounded`: the predicate that states a set is bounded (i.e., the complement of a
   cobounded set). One should prefer `Bornology.IsBounded s` over `sᶜ ∈ cobounded α`.
 - `BoundedSpace α`: a class extending `Bornology α` with the condition

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>

@@ -119,11 +119,11 @@ def Bornology.ofBounded' {α : Type _} (B : Set (Set α))
     (empty_mem : ∅ ∈ B)
     (subset_mem : ∀ s₁ (_ : s₁ ∈ B) s₂, s₂ ⊆ s₁ → s₂ ∈ B)
     (union_mem : ∀ s₁ (_ : s₁ ∈ B) s₂ (_ : s₂ ∈ B), s₁ ∪ s₂ ∈ B)
-    (unionₛ_univ : ⋃₀ B = univ) :
+    (sUnion_univ : ⋃₀ B = univ) :
     Bornology α :=
   Bornology.ofBounded B empty_mem subset_mem union_mem fun x => by
-    rw [unionₛ_eq_univ_iff] at unionₛ_univ
-    rcases unionₛ_univ x with ⟨s, hs, hxs⟩
+    rw [sUnion_eq_univ_iff] at sUnion_univ
+    rcases sUnion_univ x with ⟨s, hs, hxs⟩
     exact subset_mem s hs {x} (singleton_subset_iff.mpr hxs)
 #align bornology.of_bounded' Bornology.ofBounded'
 #align bornology.of_bounded'_cobounded_sets Bornology.ofBounded'_cobounded_sets
@@ -214,9 +214,9 @@ theorem IsBounded.subset (ht : IsBounded t) (hs : s ⊆ t) : IsBounded s :=
 #align bornology.is_bounded.subset Bornology.IsBounded.subset
 
 @[simp]
-theorem unionₛ_bounded_univ : ⋃₀ { s : Set α | IsBounded s } = univ :=
-  unionₛ_eq_univ_iff.2 fun a => ⟨{a}, isBounded_singleton, mem_singleton a⟩
-#align bornology.sUnion_bounded_univ Bornology.unionₛ_bounded_univ
+theorem sUnion_bounded_univ : ⋃₀ { s : Set α | IsBounded s } = univ :=
+  sUnion_eq_univ_iff.2 fun a => ⟨{a}, isBounded_singleton, mem_singleton a⟩
+#align bornology.sUnion_bounded_univ Bornology.sUnion_bounded_univ
 
 theorem comap_cobounded_le_iff [Bornology β] {f : α → β} :
     (cobounded β).comap f ≤ cobounded α ↔ ∀ ⦃s⦄, IsBounded s → IsBounded (f '' s) := by
@@ -259,46 +259,46 @@ theorem isBounded_ofBounded_iff (B : Set (Set α)) {empty_mem subset_mem union_m
 
 variable [Bornology α]
 
-theorem isCobounded_binterᵢ {s : Set ι} {f : ι → Set α} (hs : s.Finite) :
+theorem isCobounded_biInter {s : Set ι} {f : ι → Set α} (hs : s.Finite) :
     IsCobounded (⋂ i ∈ s, f i) ↔ ∀ i ∈ s, IsCobounded (f i) :=
-  binterᵢ_mem hs
-#align bornology.is_cobounded_bInter Bornology.isCobounded_binterᵢ
+  biInter_mem hs
+#align bornology.is_cobounded_bInter Bornology.isCobounded_biInter
 
 @[simp]
-theorem isCobounded_binterᵢ_finset (s : Finset ι) {f : ι → Set α} :
+theorem isCobounded_biInter_finset (s : Finset ι) {f : ι → Set α} :
     IsCobounded (⋂ i ∈ s, f i) ↔ ∀ i ∈ s, IsCobounded (f i) :=
-  binterᵢ_finset_mem s
-#align bornology.is_cobounded_bInter_finset Bornology.isCobounded_binterᵢ_finset
+  biInter_finset_mem s
+#align bornology.is_cobounded_bInter_finset Bornology.isCobounded_biInter_finset
 
 @[simp]
-theorem isCobounded_interᵢ [Finite ι] {f : ι → Set α} :
+theorem isCobounded_iInter [Finite ι] {f : ι → Set α} :
     IsCobounded (⋂ i, f i) ↔ ∀ i, IsCobounded (f i) :=
-  interᵢ_mem
-#align bornology.is_cobounded_Inter Bornology.isCobounded_interᵢ
+  iInter_mem
+#align bornology.is_cobounded_Inter Bornology.isCobounded_iInter
 
-theorem isCobounded_interₛ {S : Set (Set α)} (hs : S.Finite) :
+theorem isCobounded_sInter {S : Set (Set α)} (hs : S.Finite) :
     IsCobounded (⋂₀ S) ↔ ∀ s ∈ S, IsCobounded s :=
-  interₛ_mem hs
-#align bornology.is_cobounded_sInter Bornology.isCobounded_interₛ
+  sInter_mem hs
+#align bornology.is_cobounded_sInter Bornology.isCobounded_sInter
 
-theorem isBounded_bunionᵢ {s : Set ι} {f : ι → Set α} (hs : s.Finite) :
+theorem isBounded_biUnion {s : Set ι} {f : ι → Set α} (hs : s.Finite) :
     IsBounded (⋃ i ∈ s, f i) ↔ ∀ i ∈ s, IsBounded (f i) := by
-  simp only [← isCobounded_compl_iff, compl_unionᵢ, isCobounded_binterᵢ hs]
-#align bornology.is_bounded_bUnion Bornology.isBounded_bunionᵢ
+  simp only [← isCobounded_compl_iff, compl_iUnion, isCobounded_biInter hs]
+#align bornology.is_bounded_bUnion Bornology.isBounded_biUnion
 
-theorem isBounded_bunionᵢ_finset (s : Finset ι) {f : ι → Set α} :
+theorem isBounded_biUnion_finset (s : Finset ι) {f : ι → Set α} :
     IsBounded (⋃ i ∈ s, f i) ↔ ∀ i ∈ s, IsBounded (f i) :=
-  isBounded_bunionᵢ s.finite_toSet
-#align bornology.is_bounded_bUnion_finset Bornology.isBounded_bunionᵢ_finset
+  isBounded_biUnion s.finite_toSet
+#align bornology.is_bounded_bUnion_finset Bornology.isBounded_biUnion_finset
 
-theorem isBounded_unionₛ {S : Set (Set α)} (hs : S.Finite) :
-    IsBounded (⋃₀ S) ↔ ∀ s ∈ S, IsBounded s := by rw [unionₛ_eq_bunionᵢ, isBounded_bunionᵢ hs]
-#align bornology.is_bounded_sUnion Bornology.isBounded_unionₛ
+theorem isBounded_sUnion {S : Set (Set α)} (hs : S.Finite) :
+    IsBounded (⋃₀ S) ↔ ∀ s ∈ S, IsBounded s := by rw [sUnion_eq_biUnion, isBounded_biUnion hs]
+#align bornology.is_bounded_sUnion Bornology.isBounded_sUnion
 
 @[simp]
-theorem isBounded_unionᵢ [Finite ι] {s : ι → Set α} : IsBounded (⋃ i, s i) ↔ ∀ i, IsBounded (s i) :=
-  by rw [← unionₛ_range, isBounded_unionₛ (finite_range s), forall_range_iff]
-#align bornology.is_bounded_Union Bornology.isBounded_unionᵢ
+theorem isBounded_iUnion [Finite ι] {s : ι → Set α} : IsBounded (⋃ i, s i) ↔ ∀ i, IsBounded (s i) :=
+  by rw [← sUnion_range, isBounded_sUnion (finite_range s), forall_range_iff]
+#align bornology.is_bounded_Union Bornology.isBounded_iUnion
 
 end Bornology
 

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

@@ -121,8 +121,7 @@ def Bornology.ofBounded' {α : Type _} (B : Set (Set α))
     (union_mem : ∀ s₁ (_ : s₁ ∈ B) s₂ (_ : s₂ ∈ B), s₁ ∪ s₂ ∈ B)
     (unionₛ_univ : ⋃₀ B = univ) :
     Bornology α :=
-  Bornology.ofBounded B empty_mem subset_mem union_mem fun x =>
-    by
+  Bornology.ofBounded B empty_mem subset_mem union_mem fun x => by
     rw [unionₛ_eq_univ_iff] at unionₛ_univ
     rcases unionₛ_univ x with ⟨s, hs, hxs⟩
     exact subset_mem s hs {x} (singleton_subset_iff.mpr hxs)

• This does not change the behavior of simps, just raises a linter error if you run simps in a more expensive mode without writing !.
• Fixed some incorrect occurrences of to_additive, simps. Will do that systematically in future PR.
• Fix port of OmegaCompletePartialOrder.ContinuousHom.ofMono a bit

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

@@ -114,7 +114,7 @@ def Bornology.ofBounded {α : Type _} (B : Set (Set α))
 
 /-- A constructor for bornologies by specifying the bounded sets,
 and showing that they satisfy the appropriate conditions. -/
-@[simps]
+@[simps!]
 def Bornology.ofBounded' {α : Type _} (B : Set (Set α))
     (empty_mem : ∅ ∈ B)
     (subset_mem : ∀ s₁ (_ : s₁ ∈ B) s₂, s₂ ⊆ s₁ → s₂ ∈ B)

porting notes:

1. There were two places where Lean couldn't figure out the type class (Bornology) arguments to isBounded_def when used within a rewrite or simp lemma, and I had to provide these explicitly. I have worked around it for now (by supplying those arguments), but Lean 3 did not have this problem and we should investigate the issue.
2. Because Lean 4 does not accept the [] syntax in structure fields to make arguments explicit, it was necessary to rename the structure fields and then provide new Bornology.cobounded and Bornology.le_cofinite declarations with the type argument explicit. See the discussion here: https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Topology.2EBornology.2EBasic