topology.metric_space.shrinking_lemma ⟷ Mathlib.Topology.MetricSpace.ShrinkingLemma

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
 -/
 import Topology.MetricSpace.Basic
-import Topology.MetricSpace.EmetricParacompact
+import Topology.EMetricSpace.Paracompact
 import Topology.ShrinkingLemma
 
 #align_import topology.metric_space.shrinking_lemma from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"

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

@@ -3,9 +3,9 @@ Copyright (c) 2021 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
 -/
-import Mathbin.Topology.MetricSpace.Basic
-import Mathbin.Topology.MetricSpace.EmetricParacompact
-import Mathbin.Topology.ShrinkingLemma
+import Topology.MetricSpace.Basic
+import Topology.MetricSpace.EmetricParacompact
+import Topology.ShrinkingLemma
 
 #align_import topology.metric_space.shrinking_lemma from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"
 

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

@@ -2,16 +2,13 @@
 Copyright (c) 2021 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
-
-! This file was ported from Lean 3 source module topology.metric_space.shrinking_lemma
-! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Topology.MetricSpace.Basic
 import Mathbin.Topology.MetricSpace.EmetricParacompact
 import Mathbin.Topology.ShrinkingLemma
 
+#align_import topology.metric_space.shrinking_lemma from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"
+
 /-!
 # Shrinking lemma in a proper metric space
 

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

@@ -37,6 +37,7 @@ variable {α : Type u} {ι : Type v} [MetricSpace α] [ProperSpace α] {c : ι 
 
 variable {x : α} {r : ℝ} {s : Set α}
 
+#print exists_subset_iUnion_ball_radius_lt /-
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a closed subset of a proper metric space by open balls can be shrunk to a new cover by open balls
 so that each of the new balls has strictly smaller radius than the old one. This version assumes
@@ -52,7 +53,9 @@ theorem exists_subset_iUnion_ball_radius_lt {r : ι → ℝ} (hs : IsClosed s)
   choose r' hlt hsub
   exact ⟨r', hsv.trans <| Union_mono <| hsub, hlt⟩
 #align exists_subset_Union_ball_radius_lt exists_subset_iUnion_ball_radius_lt
+-/
 
+#print exists_iUnion_ball_eq_radius_lt /-
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a proper metric space by open balls can be shrunk to a new cover by open balls so that each of
 the new balls has strictly smaller radius than the old one. -/
@@ -62,7 +65,9 @@ theorem exists_iUnion_ball_eq_radius_lt {r : ι → ℝ} (uf : ∀ x, {i | x ∈
   let ⟨r', hU, hv⟩ := exists_subset_iUnion_ball_radius_lt isClosed_univ (fun x _ => uf x) uU.ge
   ⟨r', univ_subset_iff.1 hU, hv⟩
 #align exists_Union_ball_eq_radius_lt exists_iUnion_ball_eq_radius_lt
+-/
 
+#print exists_subset_iUnion_ball_radius_pos_lt /-
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a closed subset of a proper metric space by nonempty open balls can be shrunk to a new cover by
 nonempty open balls so that each of the new balls has strictly smaller radius than the old one. -/
@@ -76,7 +81,9 @@ theorem exists_subset_iUnion_ball_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0
   choose r' hlt hsub
   exact ⟨r', hsv.trans <| Union_mono hsub, hlt⟩
 #align exists_subset_Union_ball_radius_pos_lt exists_subset_iUnion_ball_radius_pos_lt
+-/
 
+#print exists_iUnion_ball_eq_radius_pos_lt /-
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a proper metric space by nonempty open balls can be shrunk to a new cover by nonempty open balls
 so that each of the new balls has strictly smaller radius than the old one. -/
@@ -87,7 +94,9 @@ theorem exists_iUnion_ball_eq_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0 < r
     exists_subset_iUnion_ball_radius_pos_lt hr isClosed_univ (fun x _ => uf x) uU.ge
   ⟨r', univ_subset_iff.1 hU, hv⟩
 #align exists_Union_ball_eq_radius_pos_lt exists_iUnion_ball_eq_radius_pos_lt
+-/
 
+#print exists_locallyFinite_subset_iUnion_ball_radius_lt /-
 /-- Let `R : α → ℝ` be a (possibly discontinuous) function on a proper metric space.
 Let `s` be a closed set in `α` such that `R` is positive on `s`. Then there exists a collection of
 pairs of balls `metric.ball (c i) (r i)`, `metric.ball (c i) (r' i)` such that
@@ -114,7 +123,9 @@ theorem exists_locallyFinite_subset_iUnion_ball_radius_lt (hs : IsClosed s) {R :
     ⟨r, hsub, hlt⟩
   exact ⟨ι, c, r, r', fun i => ⟨(hr' i).1, (hlt i).1, (hlt i).2, (hr' i).2.2⟩, hfin, hsub⟩
 #align exists_locally_finite_subset_Union_ball_radius_lt exists_locallyFinite_subset_iUnion_ball_radius_lt
+-/
 
+#print exists_locallyFinite_iUnion_eq_ball_radius_lt /-
 /-- Let `R : α → ℝ` be a (possibly discontinuous) positive function on a proper metric space. Then
 there exists a collection of pairs of balls `metric.ball (c i) (r i)`, `metric.ball (c i) (r' i)`
 such that
@@ -133,4 +144,5 @@ theorem exists_locallyFinite_iUnion_eq_ball_radius_lt {R : α → ℝ} (hR : ∀
     exists_locallyFinite_subset_iUnion_ball_radius_lt isClosed_univ fun x _ => hR x
   ⟨ι, c, r, r', fun i => (hlt i).2, hfin, univ_subset_iff.1 hsub⟩
 #align exists_locally_finite_Union_eq_ball_radius_lt exists_locallyFinite_iUnion_eq_ball_radius_lt
+-/
 

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

@@ -43,7 +43,7 @@ so that each of the new balls has strictly smaller radius than the old one. This
 that `λ x, ball (c i) (r i)` is a locally finite covering and provides a covering indexed by the
 same type. -/
 theorem exists_subset_iUnion_ball_radius_lt {r : ι → ℝ} (hs : IsClosed s)
-    (uf : ∀ x ∈ s, { i | x ∈ ball (c i) (r i) }.Finite) (us : s ⊆ ⋃ i, ball (c i) (r i)) :
+    (uf : ∀ x ∈ s, {i | x ∈ ball (c i) (r i)}.Finite) (us : s ⊆ ⋃ i, ball (c i) (r i)) :
     ∃ r' : ι → ℝ, (s ⊆ ⋃ i, ball (c i) (r' i)) ∧ ∀ i, r' i < r i :=
   by
   rcases exists_subset_iUnion_closed_subset hs (fun i => @is_open_ball _ _ (c i) (r i)) uf us with
@@ -56,7 +56,7 @@ theorem exists_subset_iUnion_ball_radius_lt {r : ι → ℝ} (hs : IsClosed s)
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a proper metric space by open balls can be shrunk to a new cover by open balls so that each of
 the new balls has strictly smaller radius than the old one. -/
-theorem exists_iUnion_ball_eq_radius_lt {r : ι → ℝ} (uf : ∀ x, { i | x ∈ ball (c i) (r i) }.Finite)
+theorem exists_iUnion_ball_eq_radius_lt {r : ι → ℝ} (uf : ∀ x, {i | x ∈ ball (c i) (r i)}.Finite)
     (uU : (⋃ i, ball (c i) (r i)) = univ) :
     ∃ r' : ι → ℝ, (⋃ i, ball (c i) (r' i)) = univ ∧ ∀ i, r' i < r i :=
   let ⟨r', hU, hv⟩ := exists_subset_iUnion_ball_radius_lt isClosed_univ (fun x _ => uf x) uU.ge
@@ -67,7 +67,7 @@ theorem exists_iUnion_ball_eq_radius_lt {r : ι → ℝ} (uf : ∀ x, { i | x 
 of a closed subset of a proper metric space by nonempty open balls can be shrunk to a new cover by
 nonempty open balls so that each of the new balls has strictly smaller radius than the old one. -/
 theorem exists_subset_iUnion_ball_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0 < r i) (hs : IsClosed s)
-    (uf : ∀ x ∈ s, { i | x ∈ ball (c i) (r i) }.Finite) (us : s ⊆ ⋃ i, ball (c i) (r i)) :
+    (uf : ∀ x ∈ s, {i | x ∈ ball (c i) (r i)}.Finite) (us : s ⊆ ⋃ i, ball (c i) (r i)) :
     ∃ r' : ι → ℝ, (s ⊆ ⋃ i, ball (c i) (r' i)) ∧ ∀ i, r' i ∈ Ioo 0 (r i) :=
   by
   rcases exists_subset_iUnion_closed_subset hs (fun i => @is_open_ball _ _ (c i) (r i)) uf us with
@@ -81,7 +81,7 @@ theorem exists_subset_iUnion_ball_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0
 of a proper metric space by nonempty open balls can be shrunk to a new cover by nonempty open balls
 so that each of the new balls has strictly smaller radius than the old one. -/
 theorem exists_iUnion_ball_eq_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0 < r i)
-    (uf : ∀ x, { i | x ∈ ball (c i) (r i) }.Finite) (uU : (⋃ i, ball (c i) (r i)) = univ) :
+    (uf : ∀ x, {i | x ∈ ball (c i) (r i)}.Finite) (uU : (⋃ i, ball (c i) (r i)) = univ) :
     ∃ r' : ι → ℝ, (⋃ i, ball (c i) (r' i)) = univ ∧ ∀ i, r' i ∈ Ioo 0 (r i) :=
   let ⟨r', hU, hv⟩ :=
     exists_subset_iUnion_ball_radius_pos_lt hr isClosed_univ (fun x _ => uf x) uU.ge

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

@@ -101,7 +101,7 @@ This is a simple corollary of `refinement_of_locally_compact_sigma_compact_of_nh
 and `exists_subset_Union_ball_radius_pos_lt`. -/
 theorem exists_locallyFinite_subset_iUnion_ball_radius_lt (hs : IsClosed s) {R : α → ℝ}
     (hR : ∀ x ∈ s, 0 < R x) :
-    ∃ (ι : Type u)(c : ι → α)(r r' : ι → ℝ),
+    ∃ (ι : Type u) (c : ι → α) (r r' : ι → ℝ),
       (∀ i, c i ∈ s ∧ 0 < r i ∧ r i < r' i ∧ r' i < R (c i)) ∧
         (LocallyFinite fun i => ball (c i) (r' i)) ∧ s ⊆ ⋃ i, ball (c i) (r i) :=
   by
@@ -126,7 +126,7 @@ such that
 This is a simple corollary of `refinement_of_locally_compact_sigma_compact_of_nhds_basis`
 and `exists_Union_ball_eq_radius_pos_lt` or `exists_locally_finite_subset_Union_ball_radius_lt`. -/
 theorem exists_locallyFinite_iUnion_eq_ball_radius_lt {R : α → ℝ} (hR : ∀ x, 0 < R x) :
-    ∃ (ι : Type u)(c : ι → α)(r r' : ι → ℝ),
+    ∃ (ι : Type u) (c : ι → α) (r r' : ι → ℝ),
       (∀ i, 0 < r i ∧ r i < r' i ∧ r' i < R (c i)) ∧
         (LocallyFinite fun i => ball (c i) (r' i)) ∧ (⋃ i, ball (c i) (r i)) = univ :=
   let ⟨ι, c, r, r', hlt, hfin, hsub⟩ :=

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

@@ -31,7 +31,7 @@ universe u v
 
 open Set Metric
 
-open Topology
+open scoped Topology
 
 variable {α : Type u} {ι : Type v} [MetricSpace α] [ProperSpace α] {c : ι → α}
 

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

@@ -37,12 +37,6 @@ variable {α : Type u} {ι : Type v} [MetricSpace α] [ProperSpace α] {c : ι 
 
 variable {x : α} {r : ℝ} {s : Set α}
 
-/- warning: exists_subset_Union_ball_radius_lt -> exists_subset_iUnion_ball_radius_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {s : Set.{u1} α} {r : ι -> Real}, (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i)))) (forall (i : ι), LT.lt.{0} Real Real.hasLt (r' i) (r i))))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {s : Set.{u1} α} {r : ι -> Real}, (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i)))) (forall (i : ι), LT.lt.{0} Real Real.instLTReal (r' i) (r i))))
-Case conversion may be inaccurate. Consider using '#align exists_subset_Union_ball_radius_lt exists_subset_iUnion_ball_radius_ltₓ'. -/
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a closed subset of a proper metric space by open balls can be shrunk to a new cover by open balls
 so that each of the new balls has strictly smaller radius than the old one. This version assumes
@@ -59,12 +53,6 @@ theorem exists_subset_iUnion_ball_radius_lt {r : ι → ℝ} (hs : IsClosed s)
   exact ⟨r', hsv.trans <| Union_mono <| hsub, hlt⟩
 #align exists_subset_Union_ball_radius_lt exists_subset_iUnion_ball_radius_lt
 
-/- warning: exists_Union_ball_eq_radius_lt -> exists_iUnion_ball_eq_radius_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {r : ι -> Real}, (forall (x : α), Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))))) -> (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α)) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Set.univ.{u1} α)) (forall (i : ι), LT.lt.{0} Real Real.hasLt (r' i) (r i))))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {r : ι -> Real}, (forall (x : α), Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))))) -> (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α)) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Set.univ.{u1} α)) (forall (i : ι), LT.lt.{0} Real Real.instLTReal (r' i) (r i))))
-Case conversion may be inaccurate. Consider using '#align exists_Union_ball_eq_radius_lt exists_iUnion_ball_eq_radius_ltₓ'. -/
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a proper metric space by open balls can be shrunk to a new cover by open balls so that each of
 the new balls has strictly smaller radius than the old one. -/
@@ -75,12 +63,6 @@ theorem exists_iUnion_ball_eq_radius_lt {r : ι → ℝ} (uf : ∀ x, { i | x 
   ⟨r', univ_subset_iff.1 hU, hv⟩
 #align exists_Union_ball_eq_radius_lt exists_iUnion_ball_eq_radius_lt
 
-/- warning: exists_subset_Union_ball_radius_pos_lt -> exists_subset_iUnion_ball_radius_pos_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {s : Set.{u1} α} {r : ι -> Real}, (forall (i : ι), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)) -> (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i)))) (forall (i : ι), Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) (r' i) (Set.Ioo.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)))))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {s : Set.{u1} α} {r : ι -> Real}, (forall (i : ι), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)) -> (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i)))) (forall (i : ι), Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) (r' i) (Set.Ioo.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)))))
-Case conversion may be inaccurate. Consider using '#align exists_subset_Union_ball_radius_pos_lt exists_subset_iUnion_ball_radius_pos_ltₓ'. -/
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a closed subset of a proper metric space by nonempty open balls can be shrunk to a new cover by
 nonempty open balls so that each of the new balls has strictly smaller radius than the old one. -/
@@ -95,12 +77,6 @@ theorem exists_subset_iUnion_ball_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0
   exact ⟨r', hsv.trans <| Union_mono hsub, hlt⟩
 #align exists_subset_Union_ball_radius_pos_lt exists_subset_iUnion_ball_radius_pos_lt
 
-/- warning: exists_Union_ball_eq_radius_pos_lt -> exists_iUnion_ball_eq_radius_pos_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {r : ι -> Real}, (forall (i : ι), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)) -> (forall (x : α), Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))))) -> (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α)) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Set.univ.{u1} α)) (forall (i : ι), Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) (r' i) (Set.Ioo.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)))))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {r : ι -> Real}, (forall (i : ι), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)) -> (forall (x : α), Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))))) -> (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α)) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Set.univ.{u1} α)) (forall (i : ι), Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) (r' i) (Set.Ioo.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)))))
-Case conversion may be inaccurate. Consider using '#align exists_Union_ball_eq_radius_pos_lt exists_iUnion_ball_eq_radius_pos_ltₓ'. -/
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a proper metric space by nonempty open balls can be shrunk to a new cover by nonempty open balls
 so that each of the new balls has strictly smaller radius than the old one. -/
@@ -112,12 +88,6 @@ theorem exists_iUnion_ball_eq_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0 < r
   ⟨r', univ_subset_iff.1 hU, hv⟩
 #align exists_Union_ball_eq_radius_pos_lt exists_iUnion_ball_eq_radius_pos_lt
 
-/- warning: exists_locally_finite_subset_Union_ball_radius_lt -> exists_locallyFinite_subset_iUnion_ball_radius_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {s : Set.{u1} α}, (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall {R : α -> Real}, (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (R x))) -> (Exists.{succ (succ u1)} Type.{u1} (fun (ι : Type.{u1}) => Exists.{succ u1} (ι -> α) (fun (c : ι -> α) => Exists.{succ u1} (ι -> Real) (fun (r : ι -> Real) => Exists.{succ u1} (ι -> Real) (fun (r' : ι -> Real) => And (forall (i : ι), And (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (c i) s) (And (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)) (And (LT.lt.{0} Real Real.hasLt (r i) (r' i)) (LT.lt.{0} Real Real.hasLt (r' i) (R (c i)))))) (And (LocallyFinite.{u1, u1} ι α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.iUnion.{u1, succ u1} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {s : Set.{u1} α}, (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall {R : α -> Real}, (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (R x))) -> (Exists.{succ (succ u1)} Type.{u1} (fun (ι : Type.{u1}) => Exists.{succ u1} (ι -> α) (fun (c : ι -> α) => Exists.{succ u1} (ι -> Real) (fun (r : ι -> Real) => Exists.{succ u1} (ι -> Real) (fun (r' : ι -> Real) => And (forall (i : ι), And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (c i) s) (And (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)) (And (LT.lt.{0} Real Real.instLTReal (r i) (r' i)) (LT.lt.{0} Real Real.instLTReal (r' i) (R (c i)))))) (And (LocallyFinite.{u1, u1} ι α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.iUnion.{u1, succ u1} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))))))))
-Case conversion may be inaccurate. Consider using '#align exists_locally_finite_subset_Union_ball_radius_lt exists_locallyFinite_subset_iUnion_ball_radius_ltₓ'. -/
 /-- Let `R : α → ℝ` be a (possibly discontinuous) function on a proper metric space.
 Let `s` be a closed set in `α` such that `R` is positive on `s`. Then there exists a collection of
 pairs of balls `metric.ball (c i) (r i)`, `metric.ball (c i) (r' i)` such that
@@ -145,12 +115,6 @@ theorem exists_locallyFinite_subset_iUnion_ball_radius_lt (hs : IsClosed s) {R :
   exact ⟨ι, c, r, r', fun i => ⟨(hr' i).1, (hlt i).1, (hlt i).2, (hr' i).2.2⟩, hfin, hsub⟩
 #align exists_locally_finite_subset_Union_ball_radius_lt exists_locallyFinite_subset_iUnion_ball_radius_lt
 
-/- warning: exists_locally_finite_Union_eq_ball_radius_lt -> exists_locallyFinite_iUnion_eq_ball_radius_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {R : α -> Real}, (forall (x : α), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (R x)) -> (Exists.{succ (succ u1)} Type.{u1} (fun (ι : Type.{u1}) => Exists.{succ u1} (ι -> α) (fun (c : ι -> α) => Exists.{succ u1} (ι -> Real) (fun (r : ι -> Real) => Exists.{succ u1} (ι -> Real) (fun (r' : ι -> Real) => And (forall (i : ι), And (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)) (And (LT.lt.{0} Real Real.hasLt (r i) (r' i)) (LT.lt.{0} Real Real.hasLt (r' i) (R (c i))))) (And (LocallyFinite.{u1, u1} ι α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {R : α -> Real}, (forall (x : α), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (R x)) -> (Exists.{succ (succ u1)} Type.{u1} (fun (ι : Type.{u1}) => Exists.{succ u1} (ι -> α) (fun (c : ι -> α) => Exists.{succ u1} (ι -> Real) (fun (r : ι -> Real) => Exists.{succ u1} (ι -> Real) (fun (r' : ι -> Real) => And (forall (i : ι), And (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)) (And (LT.lt.{0} Real Real.instLTReal (r i) (r' i)) (LT.lt.{0} Real Real.instLTReal (r' i) (R (c i))))) (And (LocallyFinite.{u1, u1} ι α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α))))))))
-Case conversion may be inaccurate. Consider using '#align exists_locally_finite_Union_eq_ball_radius_lt exists_locallyFinite_iUnion_eq_ball_radius_ltₓ'. -/
 /-- Let `R : α → ℝ` be a (possibly discontinuous) positive function on a proper metric space. Then
 there exists a collection of pairs of balls `metric.ball (c i) (r i)`, `metric.ball (c i) (r' i)`
 such that

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

@@ -37,87 +37,87 @@ variable {α : Type u} {ι : Type v} [MetricSpace α] [ProperSpace α] {c : ι 
 
 variable {x : α} {r : ℝ} {s : Set α}
 
-/- warning: exists_subset_Union_ball_radius_lt -> exists_subset_unionᵢ_ball_radius_lt is a dubious translation:
+/- warning: exists_subset_Union_ball_radius_lt -> exists_subset_iUnion_ball_radius_lt is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {s : Set.{u1} α} {r : ι -> Real}, (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i)))) (forall (i : ι), LT.lt.{0} Real Real.hasLt (r' i) (r i))))
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {s : Set.{u1} α} {r : ι -> Real}, (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i)))) (forall (i : ι), LT.lt.{0} Real Real.hasLt (r' i) (r i))))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {s : Set.{u1} α} {r : ι -> Real}, (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i)))) (forall (i : ι), LT.lt.{0} Real Real.instLTReal (r' i) (r i))))
-Case conversion may be inaccurate. Consider using '#align exists_subset_Union_ball_radius_lt exists_subset_unionᵢ_ball_radius_ltₓ'. -/
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {s : Set.{u1} α} {r : ι -> Real}, (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i)))) (forall (i : ι), LT.lt.{0} Real Real.instLTReal (r' i) (r i))))
+Case conversion may be inaccurate. Consider using '#align exists_subset_Union_ball_radius_lt exists_subset_iUnion_ball_radius_ltₓ'. -/
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a closed subset of a proper metric space by open balls can be shrunk to a new cover by open balls
 so that each of the new balls has strictly smaller radius than the old one. This version assumes
 that `λ x, ball (c i) (r i)` is a locally finite covering and provides a covering indexed by the
 same type. -/
-theorem exists_subset_unionᵢ_ball_radius_lt {r : ι → ℝ} (hs : IsClosed s)
+theorem exists_subset_iUnion_ball_radius_lt {r : ι → ℝ} (hs : IsClosed s)
     (uf : ∀ x ∈ s, { i | x ∈ ball (c i) (r i) }.Finite) (us : s ⊆ ⋃ i, ball (c i) (r i)) :
     ∃ r' : ι → ℝ, (s ⊆ ⋃ i, ball (c i) (r' i)) ∧ ∀ i, r' i < r i :=
   by
-  rcases exists_subset_unionᵢ_closed_subset hs (fun i => @is_open_ball _ _ (c i) (r i)) uf us with
+  rcases exists_subset_iUnion_closed_subset hs (fun i => @is_open_ball _ _ (c i) (r i)) uf us with
     ⟨v, hsv, hvc, hcv⟩
   have := fun i => exists_lt_subset_ball (hvc i) (hcv i)
   choose r' hlt hsub
   exact ⟨r', hsv.trans <| Union_mono <| hsub, hlt⟩
-#align exists_subset_Union_ball_radius_lt exists_subset_unionᵢ_ball_radius_lt
+#align exists_subset_Union_ball_radius_lt exists_subset_iUnion_ball_radius_lt
 
-/- warning: exists_Union_ball_eq_radius_lt -> exists_unionᵢ_ball_eq_radius_lt is a dubious translation:
+/- warning: exists_Union_ball_eq_radius_lt -> exists_iUnion_ball_eq_radius_lt is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {r : ι -> Real}, (forall (x : α), Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))))) -> (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α)) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Set.univ.{u1} α)) (forall (i : ι), LT.lt.{0} Real Real.hasLt (r' i) (r i))))
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {r : ι -> Real}, (forall (x : α), Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))))) -> (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α)) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Set.univ.{u1} α)) (forall (i : ι), LT.lt.{0} Real Real.hasLt (r' i) (r i))))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {r : ι -> Real}, (forall (x : α), Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))))) -> (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α)) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Set.univ.{u1} α)) (forall (i : ι), LT.lt.{0} Real Real.instLTReal (r' i) (r i))))
-Case conversion may be inaccurate. Consider using '#align exists_Union_ball_eq_radius_lt exists_unionᵢ_ball_eq_radius_ltₓ'. -/
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {r : ι -> Real}, (forall (x : α), Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))))) -> (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α)) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Set.univ.{u1} α)) (forall (i : ι), LT.lt.{0} Real Real.instLTReal (r' i) (r i))))
+Case conversion may be inaccurate. Consider using '#align exists_Union_ball_eq_radius_lt exists_iUnion_ball_eq_radius_ltₓ'. -/
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a proper metric space by open balls can be shrunk to a new cover by open balls so that each of
 the new balls has strictly smaller radius than the old one. -/
-theorem exists_unionᵢ_ball_eq_radius_lt {r : ι → ℝ} (uf : ∀ x, { i | x ∈ ball (c i) (r i) }.Finite)
+theorem exists_iUnion_ball_eq_radius_lt {r : ι → ℝ} (uf : ∀ x, { i | x ∈ ball (c i) (r i) }.Finite)
     (uU : (⋃ i, ball (c i) (r i)) = univ) :
     ∃ r' : ι → ℝ, (⋃ i, ball (c i) (r' i)) = univ ∧ ∀ i, r' i < r i :=
-  let ⟨r', hU, hv⟩ := exists_subset_unionᵢ_ball_radius_lt isClosed_univ (fun x _ => uf x) uU.ge
+  let ⟨r', hU, hv⟩ := exists_subset_iUnion_ball_radius_lt isClosed_univ (fun x _ => uf x) uU.ge
   ⟨r', univ_subset_iff.1 hU, hv⟩
-#align exists_Union_ball_eq_radius_lt exists_unionᵢ_ball_eq_radius_lt
+#align exists_Union_ball_eq_radius_lt exists_iUnion_ball_eq_radius_lt
 
-/- warning: exists_subset_Union_ball_radius_pos_lt -> exists_subset_unionᵢ_ball_radius_pos_lt is a dubious translation:
+/- warning: exists_subset_Union_ball_radius_pos_lt -> exists_subset_iUnion_ball_radius_pos_lt is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {s : Set.{u1} α} {r : ι -> Real}, (forall (i : ι), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)) -> (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i)))) (forall (i : ι), Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) (r' i) (Set.Ioo.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)))))
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {s : Set.{u1} α} {r : ι -> Real}, (forall (i : ι), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)) -> (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i)))) (forall (i : ι), Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) (r' i) (Set.Ioo.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)))))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {s : Set.{u1} α} {r : ι -> Real}, (forall (i : ι), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)) -> (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i)))) (forall (i : ι), Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) (r' i) (Set.Ioo.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)))))
-Case conversion may be inaccurate. Consider using '#align exists_subset_Union_ball_radius_pos_lt exists_subset_unionᵢ_ball_radius_pos_ltₓ'. -/
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {s : Set.{u1} α} {r : ι -> Real}, (forall (i : ι), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)) -> (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i)))) (forall (i : ι), Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) (r' i) (Set.Ioo.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)))))
+Case conversion may be inaccurate. Consider using '#align exists_subset_Union_ball_radius_pos_lt exists_subset_iUnion_ball_radius_pos_ltₓ'. -/
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a closed subset of a proper metric space by nonempty open balls can be shrunk to a new cover by
 nonempty open balls so that each of the new balls has strictly smaller radius than the old one. -/
-theorem exists_subset_unionᵢ_ball_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0 < r i) (hs : IsClosed s)
+theorem exists_subset_iUnion_ball_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0 < r i) (hs : IsClosed s)
     (uf : ∀ x ∈ s, { i | x ∈ ball (c i) (r i) }.Finite) (us : s ⊆ ⋃ i, ball (c i) (r i)) :
     ∃ r' : ι → ℝ, (s ⊆ ⋃ i, ball (c i) (r' i)) ∧ ∀ i, r' i ∈ Ioo 0 (r i) :=
   by
-  rcases exists_subset_unionᵢ_closed_subset hs (fun i => @is_open_ball _ _ (c i) (r i)) uf us with
+  rcases exists_subset_iUnion_closed_subset hs (fun i => @is_open_ball _ _ (c i) (r i)) uf us with
     ⟨v, hsv, hvc, hcv⟩
   have := fun i => exists_pos_lt_subset_ball (hr i) (hvc i) (hcv i)
   choose r' hlt hsub
   exact ⟨r', hsv.trans <| Union_mono hsub, hlt⟩
-#align exists_subset_Union_ball_radius_pos_lt exists_subset_unionᵢ_ball_radius_pos_lt
+#align exists_subset_Union_ball_radius_pos_lt exists_subset_iUnion_ball_radius_pos_lt
 
-/- warning: exists_Union_ball_eq_radius_pos_lt -> exists_unionᵢ_ball_eq_radius_pos_lt is a dubious translation:
+/- warning: exists_Union_ball_eq_radius_pos_lt -> exists_iUnion_ball_eq_radius_pos_lt is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {r : ι -> Real}, (forall (i : ι), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)) -> (forall (x : α), Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))))) -> (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α)) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Set.univ.{u1} α)) (forall (i : ι), Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) (r' i) (Set.Ioo.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)))))
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {r : ι -> Real}, (forall (i : ι), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)) -> (forall (x : α), Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))))) -> (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α)) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Set.univ.{u1} α)) (forall (i : ι), Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) (r' i) (Set.Ioo.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)))))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {r : ι -> Real}, (forall (i : ι), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)) -> (forall (x : α), Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))))) -> (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α)) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Set.univ.{u1} α)) (forall (i : ι), Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) (r' i) (Set.Ioo.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)))))
-Case conversion may be inaccurate. Consider using '#align exists_Union_ball_eq_radius_pos_lt exists_unionᵢ_ball_eq_radius_pos_ltₓ'. -/
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {r : ι -> Real}, (forall (i : ι), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)) -> (forall (x : α), Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))))) -> (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α)) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Set.univ.{u1} α)) (forall (i : ι), Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) (r' i) (Set.Ioo.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)))))
+Case conversion may be inaccurate. Consider using '#align exists_Union_ball_eq_radius_pos_lt exists_iUnion_ball_eq_radius_pos_ltₓ'. -/
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a proper metric space by nonempty open balls can be shrunk to a new cover by nonempty open balls
 so that each of the new balls has strictly smaller radius than the old one. -/
-theorem exists_unionᵢ_ball_eq_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0 < r i)
+theorem exists_iUnion_ball_eq_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0 < r i)
     (uf : ∀ x, { i | x ∈ ball (c i) (r i) }.Finite) (uU : (⋃ i, ball (c i) (r i)) = univ) :
     ∃ r' : ι → ℝ, (⋃ i, ball (c i) (r' i)) = univ ∧ ∀ i, r' i ∈ Ioo 0 (r i) :=
   let ⟨r', hU, hv⟩ :=
-    exists_subset_unionᵢ_ball_radius_pos_lt hr isClosed_univ (fun x _ => uf x) uU.ge
+    exists_subset_iUnion_ball_radius_pos_lt hr isClosed_univ (fun x _ => uf x) uU.ge
   ⟨r', univ_subset_iff.1 hU, hv⟩
-#align exists_Union_ball_eq_radius_pos_lt exists_unionᵢ_ball_eq_radius_pos_lt
+#align exists_Union_ball_eq_radius_pos_lt exists_iUnion_ball_eq_radius_pos_lt
 
-/- warning: exists_locally_finite_subset_Union_ball_radius_lt -> exists_locallyFinite_subset_unionᵢ_ball_radius_lt is a dubious translation:
+/- warning: exists_locally_finite_subset_Union_ball_radius_lt -> exists_locallyFinite_subset_iUnion_ball_radius_lt is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {s : Set.{u1} α}, (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall {R : α -> Real}, (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (R x))) -> (Exists.{succ (succ u1)} Type.{u1} (fun (ι : Type.{u1}) => Exists.{succ u1} (ι -> α) (fun (c : ι -> α) => Exists.{succ u1} (ι -> Real) (fun (r : ι -> Real) => Exists.{succ u1} (ι -> Real) (fun (r' : ι -> Real) => And (forall (i : ι), And (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (c i) s) (And (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)) (And (LT.lt.{0} Real Real.hasLt (r i) (r' i)) (LT.lt.{0} Real Real.hasLt (r' i) (R (c i)))))) (And (LocallyFinite.{u1, u1} ι α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.unionᵢ.{u1, succ u1} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))))))))
+  forall {α : Type.{u1}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {s : Set.{u1} α}, (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall {R : α -> Real}, (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (R x))) -> (Exists.{succ (succ u1)} Type.{u1} (fun (ι : Type.{u1}) => Exists.{succ u1} (ι -> α) (fun (c : ι -> α) => Exists.{succ u1} (ι -> Real) (fun (r : ι -> Real) => Exists.{succ u1} (ι -> Real) (fun (r' : ι -> Real) => And (forall (i : ι), And (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (c i) s) (And (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)) (And (LT.lt.{0} Real Real.hasLt (r i) (r' i)) (LT.lt.{0} Real Real.hasLt (r' i) (R (c i)))))) (And (LocallyFinite.{u1, u1} ι α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.iUnion.{u1, succ u1} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))))))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {s : Set.{u1} α}, (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall {R : α -> Real}, (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (R x))) -> (Exists.{succ (succ u1)} Type.{u1} (fun (ι : Type.{u1}) => Exists.{succ u1} (ι -> α) (fun (c : ι -> α) => Exists.{succ u1} (ι -> Real) (fun (r : ι -> Real) => Exists.{succ u1} (ι -> Real) (fun (r' : ι -> Real) => And (forall (i : ι), And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (c i) s) (And (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)) (And (LT.lt.{0} Real Real.instLTReal (r i) (r' i)) (LT.lt.{0} Real Real.instLTReal (r' i) (R (c i)))))) (And (LocallyFinite.{u1, u1} ι α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.unionᵢ.{u1, succ u1} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))))))))
-Case conversion may be inaccurate. Consider using '#align exists_locally_finite_subset_Union_ball_radius_lt exists_locallyFinite_subset_unionᵢ_ball_radius_ltₓ'. -/
+  forall {α : Type.{u1}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {s : Set.{u1} α}, (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall {R : α -> Real}, (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (R x))) -> (Exists.{succ (succ u1)} Type.{u1} (fun (ι : Type.{u1}) => Exists.{succ u1} (ι -> α) (fun (c : ι -> α) => Exists.{succ u1} (ι -> Real) (fun (r : ι -> Real) => Exists.{succ u1} (ι -> Real) (fun (r' : ι -> Real) => And (forall (i : ι), And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (c i) s) (And (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)) (And (LT.lt.{0} Real Real.instLTReal (r i) (r' i)) (LT.lt.{0} Real Real.instLTReal (r' i) (R (c i)))))) (And (LocallyFinite.{u1, u1} ι α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.iUnion.{u1, succ u1} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))))))))
+Case conversion may be inaccurate. Consider using '#align exists_locally_finite_subset_Union_ball_radius_lt exists_locallyFinite_subset_iUnion_ball_radius_ltₓ'. -/
 /-- Let `R : α → ℝ` be a (possibly discontinuous) function on a proper metric space.
 Let `s` be a closed set in `α` such that `R` is positive on `s`. Then there exists a collection of
 pairs of balls `metric.ball (c i) (r i)`, `metric.ball (c i) (r' i)` such that
@@ -129,7 +129,7 @@ pairs of balls `metric.ball (c i) (r i)`, `metric.ball (c i) (r' i)` such that
 
 This is a simple corollary of `refinement_of_locally_compact_sigma_compact_of_nhds_basis_set`
 and `exists_subset_Union_ball_radius_pos_lt`. -/
-theorem exists_locallyFinite_subset_unionᵢ_ball_radius_lt (hs : IsClosed s) {R : α → ℝ}
+theorem exists_locallyFinite_subset_iUnion_ball_radius_lt (hs : IsClosed s) {R : α → ℝ}
     (hR : ∀ x ∈ s, 0 < R x) :
     ∃ (ι : Type u)(c : ι → α)(r r' : ι → ℝ),
       (∀ i, c i ∈ s ∧ 0 < r i ∧ r i < r' i ∧ r' i < R (c i)) ∧
@@ -139,18 +139,18 @@ theorem exists_locallyFinite_subset_unionᵢ_ball_radius_lt (hs : IsClosed s) {R
     nhds_basis_uniformity (uniformity_basis_dist_lt (hR x hx))
   rcases refinement_of_locallyCompact_sigmaCompact_of_nhds_basis_set hs this with
     ⟨ι, c, r', hr', hsub', hfin⟩
-  rcases exists_subset_unionᵢ_ball_radius_pos_lt (fun i => (hr' i).2.1) hs
+  rcases exists_subset_iUnion_ball_radius_pos_lt (fun i => (hr' i).2.1) hs
       (fun x hx => hfin.point_finite x) hsub' with
     ⟨r, hsub, hlt⟩
   exact ⟨ι, c, r, r', fun i => ⟨(hr' i).1, (hlt i).1, (hlt i).2, (hr' i).2.2⟩, hfin, hsub⟩
-#align exists_locally_finite_subset_Union_ball_radius_lt exists_locallyFinite_subset_unionᵢ_ball_radius_lt
+#align exists_locally_finite_subset_Union_ball_radius_lt exists_locallyFinite_subset_iUnion_ball_radius_lt
 
-/- warning: exists_locally_finite_Union_eq_ball_radius_lt -> exists_locallyFinite_unionᵢ_eq_ball_radius_lt is a dubious translation:
+/- warning: exists_locally_finite_Union_eq_ball_radius_lt -> exists_locallyFinite_iUnion_eq_ball_radius_lt is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {R : α -> Real}, (forall (x : α), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (R x)) -> (Exists.{succ (succ u1)} Type.{u1} (fun (ι : Type.{u1}) => Exists.{succ u1} (ι -> α) (fun (c : ι -> α) => Exists.{succ u1} (ι -> Real) (fun (r : ι -> Real) => Exists.{succ u1} (ι -> Real) (fun (r' : ι -> Real) => And (forall (i : ι), And (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)) (And (LT.lt.{0} Real Real.hasLt (r i) (r' i)) (LT.lt.{0} Real Real.hasLt (r' i) (R (c i))))) (And (LocallyFinite.{u1, u1} ι α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α))))))))
+  forall {α : Type.{u1}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {R : α -> Real}, (forall (x : α), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (R x)) -> (Exists.{succ (succ u1)} Type.{u1} (fun (ι : Type.{u1}) => Exists.{succ u1} (ι -> α) (fun (c : ι -> α) => Exists.{succ u1} (ι -> Real) (fun (r : ι -> Real) => Exists.{succ u1} (ι -> Real) (fun (r' : ι -> Real) => And (forall (i : ι), And (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)) (And (LT.lt.{0} Real Real.hasLt (r i) (r' i)) (LT.lt.{0} Real Real.hasLt (r' i) (R (c i))))) (And (LocallyFinite.{u1, u1} ι α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α))))))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {R : α -> Real}, (forall (x : α), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (R x)) -> (Exists.{succ (succ u1)} Type.{u1} (fun (ι : Type.{u1}) => Exists.{succ u1} (ι -> α) (fun (c : ι -> α) => Exists.{succ u1} (ι -> Real) (fun (r : ι -> Real) => Exists.{succ u1} (ι -> Real) (fun (r' : ι -> Real) => And (forall (i : ι), And (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)) (And (LT.lt.{0} Real Real.instLTReal (r i) (r' i)) (LT.lt.{0} Real Real.instLTReal (r' i) (R (c i))))) (And (LocallyFinite.{u1, u1} ι α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α))))))))
-Case conversion may be inaccurate. Consider using '#align exists_locally_finite_Union_eq_ball_radius_lt exists_locallyFinite_unionᵢ_eq_ball_radius_ltₓ'. -/
+  forall {α : Type.{u1}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {R : α -> Real}, (forall (x : α), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (R x)) -> (Exists.{succ (succ u1)} Type.{u1} (fun (ι : Type.{u1}) => Exists.{succ u1} (ι -> α) (fun (c : ι -> α) => Exists.{succ u1} (ι -> Real) (fun (r : ι -> Real) => Exists.{succ u1} (ι -> Real) (fun (r' : ι -> Real) => And (forall (i : ι), And (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)) (And (LT.lt.{0} Real Real.instLTReal (r i) (r' i)) (LT.lt.{0} Real Real.instLTReal (r' i) (R (c i))))) (And (LocallyFinite.{u1, u1} ι α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α))))))))
+Case conversion may be inaccurate. Consider using '#align exists_locally_finite_Union_eq_ball_radius_lt exists_locallyFinite_iUnion_eq_ball_radius_ltₓ'. -/
 /-- Let `R : α → ℝ` be a (possibly discontinuous) positive function on a proper metric space. Then
 there exists a collection of pairs of balls `metric.ball (c i) (r i)`, `metric.ball (c i) (r' i)`
 such that
@@ -161,12 +161,12 @@ such that
 
 This is a simple corollary of `refinement_of_locally_compact_sigma_compact_of_nhds_basis`
 and `exists_Union_ball_eq_radius_pos_lt` or `exists_locally_finite_subset_Union_ball_radius_lt`. -/
-theorem exists_locallyFinite_unionᵢ_eq_ball_radius_lt {R : α → ℝ} (hR : ∀ x, 0 < R x) :
+theorem exists_locallyFinite_iUnion_eq_ball_radius_lt {R : α → ℝ} (hR : ∀ x, 0 < R x) :
     ∃ (ι : Type u)(c : ι → α)(r r' : ι → ℝ),
       (∀ i, 0 < r i ∧ r i < r' i ∧ r' i < R (c i)) ∧
         (LocallyFinite fun i => ball (c i) (r' i)) ∧ (⋃ i, ball (c i) (r i)) = univ :=
   let ⟨ι, c, r, r', hlt, hfin, hsub⟩ :=
-    exists_locallyFinite_subset_unionᵢ_ball_radius_lt isClosed_univ fun x _ => hR x
+    exists_locallyFinite_subset_iUnion_ball_radius_lt isClosed_univ fun x _ => hR x
   ⟨ι, c, r, r', fun i => (hlt i).2, hfin, univ_subset_iff.1 hsub⟩
-#align exists_locally_finite_Union_eq_ball_radius_lt exists_locallyFinite_unionᵢ_eq_ball_radius_lt
+#align exists_locally_finite_Union_eq_ball_radius_lt exists_locallyFinite_iUnion_eq_ball_radius_lt
 

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
 
 ! This file was ported from Lean 3 source module topology.metric_space.shrinking_lemma
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
+! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -15,6 +15,9 @@ import Mathbin.Topology.ShrinkingLemma
 /-!
 # Shrinking lemma in a proper metric space
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 In this file we prove a few versions of the shrinking lemma for coverings by balls in a proper
 (pseudo) metric space.
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/641b6a82006416ec431b2987b354af9311fed4f2

@@ -34,6 +34,12 @@ variable {α : Type u} {ι : Type v} [MetricSpace α] [ProperSpace α] {c : ι 
 
 variable {x : α} {r : ℝ} {s : Set α}
 
+/- warning: exists_subset_Union_ball_radius_lt -> exists_subset_unionᵢ_ball_radius_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {s : Set.{u1} α} {r : ι -> Real}, (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i)))) (forall (i : ι), LT.lt.{0} Real Real.hasLt (r' i) (r i))))
+but is expected to have type
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {s : Set.{u1} α} {r : ι -> Real}, (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i)))) (forall (i : ι), LT.lt.{0} Real Real.instLTReal (r' i) (r i))))
+Case conversion may be inaccurate. Consider using '#align exists_subset_Union_ball_radius_lt exists_subset_unionᵢ_ball_radius_ltₓ'. -/
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a closed subset of a proper metric space by open balls can be shrunk to a new cover by open balls
 so that each of the new balls has strictly smaller radius than the old one. This version assumes
@@ -50,6 +56,12 @@ theorem exists_subset_unionᵢ_ball_radius_lt {r : ι → ℝ} (hs : IsClosed s)
   exact ⟨r', hsv.trans <| Union_mono <| hsub, hlt⟩
 #align exists_subset_Union_ball_radius_lt exists_subset_unionᵢ_ball_radius_lt
 
+/- warning: exists_Union_ball_eq_radius_lt -> exists_unionᵢ_ball_eq_radius_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {r : ι -> Real}, (forall (x : α), Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))))) -> (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α)) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Set.univ.{u1} α)) (forall (i : ι), LT.lt.{0} Real Real.hasLt (r' i) (r i))))
+but is expected to have type
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {r : ι -> Real}, (forall (x : α), Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))))) -> (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α)) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Set.univ.{u1} α)) (forall (i : ι), LT.lt.{0} Real Real.instLTReal (r' i) (r i))))
+Case conversion may be inaccurate. Consider using '#align exists_Union_ball_eq_radius_lt exists_unionᵢ_ball_eq_radius_ltₓ'. -/
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a proper metric space by open balls can be shrunk to a new cover by open balls so that each of
 the new balls has strictly smaller radius than the old one. -/
@@ -60,6 +72,12 @@ theorem exists_unionᵢ_ball_eq_radius_lt {r : ι → ℝ} (uf : ∀ x, { i | x
   ⟨r', univ_subset_iff.1 hU, hv⟩
 #align exists_Union_ball_eq_radius_lt exists_unionᵢ_ball_eq_radius_lt
 
+/- warning: exists_subset_Union_ball_radius_pos_lt -> exists_subset_unionᵢ_ball_radius_pos_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {s : Set.{u1} α} {r : ι -> Real}, (forall (i : ι), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)) -> (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i)))) (forall (i : ι), Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) (r' i) (Set.Ioo.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)))))
+but is expected to have type
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {s : Set.{u1} α} {r : ι -> Real}, (forall (i : ι), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)) -> (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i)))) (forall (i : ι), Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) (r' i) (Set.Ioo.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)))))
+Case conversion may be inaccurate. Consider using '#align exists_subset_Union_ball_radius_pos_lt exists_subset_unionᵢ_ball_radius_pos_ltₓ'. -/
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a closed subset of a proper metric space by nonempty open balls can be shrunk to a new cover by
 nonempty open balls so that each of the new balls has strictly smaller radius than the old one. -/
@@ -74,6 +92,12 @@ theorem exists_subset_unionᵢ_ball_radius_pos_lt {r : ι → ℝ} (hr : ∀ i,
   exact ⟨r', hsv.trans <| Union_mono hsub, hlt⟩
 #align exists_subset_Union_ball_radius_pos_lt exists_subset_unionᵢ_ball_radius_pos_lt
 
+/- warning: exists_Union_ball_eq_radius_pos_lt -> exists_unionᵢ_ball_eq_radius_pos_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {r : ι -> Real}, (forall (i : ι), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)) -> (forall (x : α), Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))))) -> (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α)) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Set.univ.{u1} α)) (forall (i : ι), Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) (r' i) (Set.Ioo.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)))))
+but is expected to have type
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {c : ι -> α} {r : ι -> Real}, (forall (i : ι), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)) -> (forall (x : α), Set.Finite.{u2} ι (setOf.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))))) -> (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α)) -> (Exists.{succ u2} (ι -> Real) (fun (r' : ι -> Real) => And (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Set.univ.{u1} α)) (forall (i : ι), Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) (r' i) (Set.Ioo.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)))))
+Case conversion may be inaccurate. Consider using '#align exists_Union_ball_eq_radius_pos_lt exists_unionᵢ_ball_eq_radius_pos_ltₓ'. -/
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a proper metric space by nonempty open balls can be shrunk to a new cover by nonempty open balls
 so that each of the new balls has strictly smaller radius than the old one. -/
@@ -85,6 +109,12 @@ theorem exists_unionᵢ_ball_eq_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0 <
   ⟨r', univ_subset_iff.1 hU, hv⟩
 #align exists_Union_ball_eq_radius_pos_lt exists_unionᵢ_ball_eq_radius_pos_lt
 
+/- warning: exists_locally_finite_subset_Union_ball_radius_lt -> exists_locallyFinite_subset_unionᵢ_ball_radius_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {s : Set.{u1} α}, (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall {R : α -> Real}, (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (R x))) -> (Exists.{succ (succ u1)} Type.{u1} (fun (ι : Type.{u1}) => Exists.{succ u1} (ι -> α) (fun (c : ι -> α) => Exists.{succ u1} (ι -> Real) (fun (r : ι -> Real) => Exists.{succ u1} (ι -> Real) (fun (r' : ι -> Real) => And (forall (i : ι), And (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (c i) s) (And (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)) (And (LT.lt.{0} Real Real.hasLt (r i) (r' i)) (LT.lt.{0} Real Real.hasLt (r' i) (R (c i)))))) (And (LocallyFinite.{u1, u1} ι α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s (Set.unionᵢ.{u1, succ u1} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {s : Set.{u1} α}, (IsClosed.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) s) -> (forall {R : α -> Real}, (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (R x))) -> (Exists.{succ (succ u1)} Type.{u1} (fun (ι : Type.{u1}) => Exists.{succ u1} (ι -> α) (fun (c : ι -> α) => Exists.{succ u1} (ι -> Real) (fun (r : ι -> Real) => Exists.{succ u1} (ι -> Real) (fun (r' : ι -> Real) => And (forall (i : ι), And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (c i) s) (And (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)) (And (LT.lt.{0} Real Real.instLTReal (r i) (r' i)) (LT.lt.{0} Real Real.instLTReal (r' i) (R (c i)))))) (And (LocallyFinite.{u1, u1} ι α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s (Set.unionᵢ.{u1, succ u1} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i)))))))))))
+Case conversion may be inaccurate. Consider using '#align exists_locally_finite_subset_Union_ball_radius_lt exists_locallyFinite_subset_unionᵢ_ball_radius_ltₓ'. -/
 /-- Let `R : α → ℝ` be a (possibly discontinuous) function on a proper metric space.
 Let `s` be a closed set in `α` such that `R` is positive on `s`. Then there exists a collection of
 pairs of balls `metric.ball (c i) (r i)`, `metric.ball (c i) (r' i)` such that
@@ -112,6 +142,12 @@ theorem exists_locallyFinite_subset_unionᵢ_ball_radius_lt (hs : IsClosed s) {R
   exact ⟨ι, c, r, r', fun i => ⟨(hr' i).1, (hlt i).1, (hlt i).2, (hr' i).2.2⟩, hfin, hsub⟩
 #align exists_locally_finite_subset_Union_ball_radius_lt exists_locallyFinite_subset_unionᵢ_ball_radius_lt
 
+/- warning: exists_locally_finite_Union_eq_ball_radius_lt -> exists_locallyFinite_unionᵢ_eq_ball_radius_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {R : α -> Real}, (forall (x : α), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (R x)) -> (Exists.{succ (succ u1)} Type.{u1} (fun (ι : Type.{u1}) => Exists.{succ u1} (ι -> α) (fun (c : ι -> α) => Exists.{succ u1} (ι -> Real) (fun (r : ι -> Real) => Exists.{succ u1} (ι -> Real) (fun (r' : ι -> Real) => And (forall (i : ι), And (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (r i)) (And (LT.lt.{0} Real Real.hasLt (r i) (r' i)) (LT.lt.{0} Real Real.hasLt (r' i) (R (c i))))) (And (LocallyFinite.{u1, u1} ι α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : MetricSpace.{u1} α] [_inst_2 : ProperSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1)] {R : α -> Real}, (forall (x : α), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (R x)) -> (Exists.{succ (succ u1)} Type.{u1} (fun (ι : Type.{u1}) => Exists.{succ u1} (ι -> α) (fun (c : ι -> α) => Exists.{succ u1} (ι -> Real) (fun (r : ι -> Real) => Exists.{succ u1} (ι -> Real) (fun (r' : ι -> Real) => And (forall (i : ι), And (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (r i)) (And (LT.lt.{0} Real Real.instLTReal (r i) (r' i)) (LT.lt.{0} Real Real.instLTReal (r' i) (R (c i))))) (And (LocallyFinite.{u1, u1} ι α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1))) (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r' i))) (Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α ι (fun (i : ι) => Metric.ball.{u1} α (MetricSpace.toPseudoMetricSpace.{u1} α _inst_1) (c i) (r i))) (Set.univ.{u1} α))))))))
+Case conversion may be inaccurate. Consider using '#align exists_locally_finite_Union_eq_ball_radius_lt exists_locallyFinite_unionᵢ_eq_ball_radius_ltₓ'. -/
 /-- Let `R : α → ℝ` be a (possibly discontinuous) positive function on a proper metric space. Then
 there exists a collection of pairs of balls `metric.ball (c i) (r i)`, `metric.ball (c i) (r' i)`
 such that

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

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

@@ -28,7 +28,6 @@ open Set Metric
 open Topology
 
 variable {α : Type u} {ι : Type v} [MetricSpace α] [ProperSpace α] {c : ι → α}
-
 variable {x : α} {r : ℝ} {s : Set α}
 
 /-- **Shrinking lemma** for coverings by open balls in a proper metric space. A point-finite open

@@ -31,11 +31,11 @@ variable {α : Type u} {ι : Type v} [MetricSpace α] [ProperSpace α] {c : ι 
 
 variable {x : α} {r : ℝ} {s : Set α}
 
-/-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
-of a closed subset of a proper metric space by open balls can be shrunk to a new cover by open balls
-so that each of the new balls has strictly smaller radius than the old one. This version assumes
-that `fun x ↦ ball (c i) (r i)` is a locally finite covering and provides a covering indexed by the
-same type. -/
+/-- **Shrinking lemma** for coverings by open balls in a proper metric space. A point-finite open
+cover of a closed subset of a proper metric space by open balls can be shrunk to a new cover by
+open balls so that each of the new balls has strictly smaller radius than the old one. This version
+assumes that `fun x ↦ ball (c i) (r i)` is a locally finite covering and provides a covering
+indexed by the same type. -/
 theorem exists_subset_iUnion_ball_radius_lt {r : ι → ℝ} (hs : IsClosed s)
     (uf : ∀ x ∈ s, { i | x ∈ ball (c i) (r i) }.Finite) (us : s ⊆ ⋃ i, ball (c i) (r i)) :
     ∃ r' : ι → ℝ, (s ⊆ ⋃ i, ball (c i) (r' i)) ∧ ∀ i, r' i < r i := by

Later I'm going to split files like Lipschitz into 2: one in EMetricSpace/ and one in MetricSpace/.

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
 -/
 import Mathlib.Topology.MetricSpace.Basic
-import Mathlib.Topology.MetricSpace.EMetricParacompact
+import Mathlib.Topology.EMetricSpace.Paracompact
 import Mathlib.Topology.ShrinkingLemma
 
 #align_import topology.metric_space.shrinking_lemma from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"

• depends on: #5966

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

@@ -2,16 +2,13 @@
 Copyright (c) 2021 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
-
-! This file was ported from Lean 3 source module topology.metric_space.shrinking_lemma
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Topology.MetricSpace.Basic
 import Mathlib.Topology.MetricSpace.EMetricParacompact
 import Mathlib.Topology.ShrinkingLemma
 
+#align_import topology.metric_space.shrinking_lemma from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
+
 /-!
 # Shrinking lemma in a proper metric space
 

@@ -53,8 +53,8 @@ theorem exists_subset_iUnion_ball_radius_lt {r : ι → ℝ} (hs : IsClosed s)
 of a proper metric space by open balls can be shrunk to a new cover by open balls so that each of
 the new balls has strictly smaller radius than the old one. -/
 theorem exists_iUnion_ball_eq_radius_lt {r : ι → ℝ} (uf : ∀ x, { i | x ∈ ball (c i) (r i) }.Finite)
-    (uU : (⋃ i, ball (c i) (r i)) = univ) :
-    ∃ r' : ι → ℝ, (⋃ i, ball (c i) (r' i)) = univ ∧ ∀ i, r' i < r i :=
+    (uU : ⋃ i, ball (c i) (r i) = univ) :
+    ∃ r' : ι → ℝ, ⋃ i, ball (c i) (r' i) = univ ∧ ∀ i, r' i < r i :=
   let ⟨r', hU, hv⟩ := exists_subset_iUnion_ball_radius_lt isClosed_univ (fun x _ => uf x) uU.ge
   ⟨r', univ_subset_iff.1 hU, hv⟩
 #align exists_Union_ball_eq_radius_lt exists_iUnion_ball_eq_radius_lt
@@ -76,8 +76,8 @@ theorem exists_subset_iUnion_ball_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0
 of a proper metric space by nonempty open balls can be shrunk to a new cover by nonempty open balls
 so that each of the new balls has strictly smaller radius than the old one. -/
 theorem exists_iUnion_ball_eq_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0 < r i)
-    (uf : ∀ x, { i | x ∈ ball (c i) (r i) }.Finite) (uU : (⋃ i, ball (c i) (r i)) = univ) :
-    ∃ r' : ι → ℝ, (⋃ i, ball (c i) (r' i)) = univ ∧ ∀ i, r' i ∈ Ioo 0 (r i) :=
+    (uf : ∀ x, { i | x ∈ ball (c i) (r i) }.Finite) (uU : ⋃ i, ball (c i) (r i) = univ) :
+    ∃ r' : ι → ℝ, ⋃ i, ball (c i) (r' i) = univ ∧ ∀ i, r' i ∈ Ioo 0 (r i) :=
   let ⟨r', hU, hv⟩ :=
     exists_subset_iUnion_ball_radius_pos_lt hr isClosed_univ (fun x _ => uf x) uU.ge
   ⟨r', univ_subset_iff.1 hU, hv⟩
@@ -122,7 +122,7 @@ and `exists_iUnion_ball_eq_radius_pos_lt` or `exists_locallyFinite_subset_iUnion
 theorem exists_locallyFinite_iUnion_eq_ball_radius_lt {R : α → ℝ} (hR : ∀ x, 0 < R x) :
     ∃ (ι : Type u) (c : ι → α) (r r' : ι → ℝ),
       (∀ i, 0 < r i ∧ r i < r' i ∧ r' i < R (c i)) ∧
-        (LocallyFinite fun i => ball (c i) (r' i)) ∧ (⋃ i, ball (c i) (r i)) = univ :=
+        (LocallyFinite fun i => ball (c i) (r' i)) ∧ ⋃ i, ball (c i) (r i) = univ :=
   let ⟨ι, c, r, r', hlt, hfin, hsub⟩ :=
     exists_locallyFinite_subset_iUnion_ball_radius_lt isClosed_univ fun x _ => hR x
   ⟨ι, c, r, r', fun i => (hlt i).2, hfin, univ_subset_iff.1 hsub⟩

Found with git grep -n "λ [a-zA-Z_ ]*,"

@@ -37,7 +37,7 @@ variable {x : α} {r : ℝ} {s : Set α}
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a closed subset of a proper metric space by open balls can be shrunk to a new cover by open balls
 so that each of the new balls has strictly smaller radius than the old one. This version assumes
-that `λ x, ball (c i) (r i)` is a locally finite covering and provides a covering indexed by the
+that `fun x ↦ ball (c i) (r i)` is a locally finite covering and provides a covering indexed by the
 same type. -/
 theorem exists_subset_iUnion_ball_radius_lt {r : ι → ℝ} (hs : IsClosed s)
     (uf : ∀ x ∈ s, { i | x ∈ ball (c i) (r i) }.Finite) (us : s ⊆ ⋃ i, ball (c i) (r i)) :

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -96,7 +96,7 @@ This is a simple corollary of `refinement_of_locallyCompact_sigmaCompact_of_nhds
 and `exists_subset_iUnion_ball_radius_pos_lt`. -/
 theorem exists_locallyFinite_subset_iUnion_ball_radius_lt (hs : IsClosed s) {R : α → ℝ}
     (hR : ∀ x ∈ s, 0 < R x) :
-    ∃ (ι : Type u)(c : ι → α)(r r' : ι → ℝ),
+    ∃ (ι : Type u) (c : ι → α) (r r' : ι → ℝ),
       (∀ i, c i ∈ s ∧ 0 < r i ∧ r i < r' i ∧ r' i < R (c i)) ∧
         (LocallyFinite fun i => ball (c i) (r' i)) ∧ s ⊆ ⋃ i, ball (c i) (r i) := by
   have : ∀ x ∈ s, (𝓝 x).HasBasis (fun r : ℝ => 0 < r ∧ r < R x) fun r => ball x r := fun x hx =>
@@ -120,7 +120,7 @@ such that
 This is a simple corollary of `refinement_of_locallyCompact_sigmaCompact_of_nhds_basis`
 and `exists_iUnion_ball_eq_radius_pos_lt` or `exists_locallyFinite_subset_iUnion_ball_radius_lt`. -/
 theorem exists_locallyFinite_iUnion_eq_ball_radius_lt {R : α → ℝ} (hR : ∀ x, 0 < R x) :
-    ∃ (ι : Type u)(c : ι → α)(r r' : ι → ℝ),
+    ∃ (ι : Type u) (c : ι → α) (r r' : ι → ℝ),
       (∀ i, 0 < r i ∧ r i < r' i ∧ r' i < R (c i)) ∧
         (LocallyFinite fun i => ball (c i) (r' i)) ∧ (⋃ i, ball (c i) (r i)) = univ :=
   let ⟨ι, c, r, r', hlt, hfin, hsub⟩ :=

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>

@@ -39,49 +39,49 @@ of a closed subset of a proper metric space by open balls can be shrunk to a new
 so that each of the new balls has strictly smaller radius than the old one. This version assumes
 that `λ x, ball (c i) (r i)` is a locally finite covering and provides a covering indexed by the
 same type. -/
-theorem exists_subset_unionᵢ_ball_radius_lt {r : ι → ℝ} (hs : IsClosed s)
+theorem exists_subset_iUnion_ball_radius_lt {r : ι → ℝ} (hs : IsClosed s)
     (uf : ∀ x ∈ s, { i | x ∈ ball (c i) (r i) }.Finite) (us : s ⊆ ⋃ i, ball (c i) (r i)) :
     ∃ r' : ι → ℝ, (s ⊆ ⋃ i, ball (c i) (r' i)) ∧ ∀ i, r' i < r i := by
-  rcases exists_subset_unionᵢ_closed_subset hs (fun i => @isOpen_ball _ _ (c i) (r i)) uf us with
+  rcases exists_subset_iUnion_closed_subset hs (fun i => @isOpen_ball _ _ (c i) (r i)) uf us with
     ⟨v, hsv, hvc, hcv⟩
   have := fun i => exists_lt_subset_ball (hvc i) (hcv i)
   choose r' hlt hsub using this
-  exact ⟨r', hsv.trans <| unionᵢ_mono <| hsub, hlt⟩
-#align exists_subset_Union_ball_radius_lt exists_subset_unionᵢ_ball_radius_lt
+  exact ⟨r', hsv.trans <| iUnion_mono <| hsub, hlt⟩
+#align exists_subset_Union_ball_radius_lt exists_subset_iUnion_ball_radius_lt
 
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a proper metric space by open balls can be shrunk to a new cover by open balls so that each of
 the new balls has strictly smaller radius than the old one. -/
-theorem exists_unionᵢ_ball_eq_radius_lt {r : ι → ℝ} (uf : ∀ x, { i | x ∈ ball (c i) (r i) }.Finite)
+theorem exists_iUnion_ball_eq_radius_lt {r : ι → ℝ} (uf : ∀ x, { i | x ∈ ball (c i) (r i) }.Finite)
     (uU : (⋃ i, ball (c i) (r i)) = univ) :
     ∃ r' : ι → ℝ, (⋃ i, ball (c i) (r' i)) = univ ∧ ∀ i, r' i < r i :=
-  let ⟨r', hU, hv⟩ := exists_subset_unionᵢ_ball_radius_lt isClosed_univ (fun x _ => uf x) uU.ge
+  let ⟨r', hU, hv⟩ := exists_subset_iUnion_ball_radius_lt isClosed_univ (fun x _ => uf x) uU.ge
   ⟨r', univ_subset_iff.1 hU, hv⟩
-#align exists_Union_ball_eq_radius_lt exists_unionᵢ_ball_eq_radius_lt
+#align exists_Union_ball_eq_radius_lt exists_iUnion_ball_eq_radius_lt
 
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a closed subset of a proper metric space by nonempty open balls can be shrunk to a new cover by
 nonempty open balls so that each of the new balls has strictly smaller radius than the old one. -/
-theorem exists_subset_unionᵢ_ball_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0 < r i) (hs : IsClosed s)
+theorem exists_subset_iUnion_ball_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0 < r i) (hs : IsClosed s)
     (uf : ∀ x ∈ s, { i | x ∈ ball (c i) (r i) }.Finite) (us : s ⊆ ⋃ i, ball (c i) (r i)) :
     ∃ r' : ι → ℝ, (s ⊆ ⋃ i, ball (c i) (r' i)) ∧ ∀ i, r' i ∈ Ioo 0 (r i) := by
-  rcases exists_subset_unionᵢ_closed_subset hs (fun i => @isOpen_ball _ _ (c i) (r i)) uf us with
+  rcases exists_subset_iUnion_closed_subset hs (fun i => @isOpen_ball _ _ (c i) (r i)) uf us with
     ⟨v, hsv, hvc, hcv⟩
   have := fun i => exists_pos_lt_subset_ball (hr i) (hvc i) (hcv i)
   choose r' hlt hsub using this
-  exact ⟨r', hsv.trans <| unionᵢ_mono hsub, hlt⟩
-#align exists_subset_Union_ball_radius_pos_lt exists_subset_unionᵢ_ball_radius_pos_lt
+  exact ⟨r', hsv.trans <| iUnion_mono hsub, hlt⟩
+#align exists_subset_Union_ball_radius_pos_lt exists_subset_iUnion_ball_radius_pos_lt
 
 /-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
 of a proper metric space by nonempty open balls can be shrunk to a new cover by nonempty open balls
 so that each of the new balls has strictly smaller radius than the old one. -/
-theorem exists_unionᵢ_ball_eq_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0 < r i)
+theorem exists_iUnion_ball_eq_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0 < r i)
     (uf : ∀ x, { i | x ∈ ball (c i) (r i) }.Finite) (uU : (⋃ i, ball (c i) (r i)) = univ) :
     ∃ r' : ι → ℝ, (⋃ i, ball (c i) (r' i)) = univ ∧ ∀ i, r' i ∈ Ioo 0 (r i) :=
   let ⟨r', hU, hv⟩ :=
-    exists_subset_unionᵢ_ball_radius_pos_lt hr isClosed_univ (fun x _ => uf x) uU.ge
+    exists_subset_iUnion_ball_radius_pos_lt hr isClosed_univ (fun x _ => uf x) uU.ge
   ⟨r', univ_subset_iff.1 hU, hv⟩
-#align exists_Union_ball_eq_radius_pos_lt exists_unionᵢ_ball_eq_radius_pos_lt
+#align exists_Union_ball_eq_radius_pos_lt exists_iUnion_ball_eq_radius_pos_lt
 
 /-- Let `R : α → ℝ` be a (possibly discontinuous) function on a proper metric space.
 Let `s` be a closed set in `α` such that `R` is positive on `s`. Then there exists a collection of
@@ -93,8 +93,8 @@ pairs of balls `Metric.ball (c i) (r i)`, `Metric.ball (c i) (r' i)` such that
 * the balls `Metric.ball (c i) (r i)` cover `s`.
 
 This is a simple corollary of `refinement_of_locallyCompact_sigmaCompact_of_nhds_basis_set`
-and `exists_subset_unionᵢ_ball_radius_pos_lt`. -/
-theorem exists_locallyFinite_subset_unionᵢ_ball_radius_lt (hs : IsClosed s) {R : α → ℝ}
+and `exists_subset_iUnion_ball_radius_pos_lt`. -/
+theorem exists_locallyFinite_subset_iUnion_ball_radius_lt (hs : IsClosed s) {R : α → ℝ}
     (hR : ∀ x ∈ s, 0 < R x) :
     ∃ (ι : Type u)(c : ι → α)(r r' : ι → ℝ),
       (∀ i, c i ∈ s ∧ 0 < r i ∧ r i < r' i ∧ r' i < R (c i)) ∧
@@ -103,11 +103,11 @@ theorem exists_locallyFinite_subset_unionᵢ_ball_radius_lt (hs : IsClosed s) {R
     nhds_basis_uniformity (uniformity_basis_dist_lt (hR x hx))
   rcases refinement_of_locallyCompact_sigmaCompact_of_nhds_basis_set hs this with
     ⟨ι, c, r', hr', hsub', hfin⟩
-  rcases exists_subset_unionᵢ_ball_radius_pos_lt (fun i => (hr' i).2.1) hs
+  rcases exists_subset_iUnion_ball_radius_pos_lt (fun i => (hr' i).2.1) hs
       (fun x _ => hfin.point_finite x) hsub' with
     ⟨r, hsub, hlt⟩
   exact ⟨ι, c, r, r', fun i => ⟨(hr' i).1, (hlt i).1, (hlt i).2, (hr' i).2.2⟩, hfin, hsub⟩
-#align exists_locally_finite_subset_Union_ball_radius_lt exists_locallyFinite_subset_unionᵢ_ball_radius_lt
+#align exists_locally_finite_subset_Union_ball_radius_lt exists_locallyFinite_subset_iUnion_ball_radius_lt
 
 /-- Let `R : α → ℝ` be a (possibly discontinuous) positive function on a proper metric space. Then
 there exists a collection of pairs of balls `Metric.ball (c i) (r i)`, `Metric.ball (c i) (r' i)`
@@ -118,13 +118,12 @@ such that
 * the balls `Metric.ball (c i) (r i)` cover the whole space.
 
 This is a simple corollary of `refinement_of_locallyCompact_sigmaCompact_of_nhds_basis`
-and `exists_unionᵢ_ball_eq_radius_pos_lt` or `exists_locallyFinite_subset_unionᵢ_ball_radius_lt`. -/
-theorem exists_locallyFinite_unionᵢ_eq_ball_radius_lt {R : α → ℝ} (hR : ∀ x, 0 < R x) :
+and `exists_iUnion_ball_eq_radius_pos_lt` or `exists_locallyFinite_subset_iUnion_ball_radius_lt`. -/
+theorem exists_locallyFinite_iUnion_eq_ball_radius_lt {R : α → ℝ} (hR : ∀ x, 0 < R x) :
     ∃ (ι : Type u)(c : ι → α)(r r' : ι → ℝ),
       (∀ i, 0 < r i ∧ r i < r' i ∧ r' i < R (c i)) ∧
         (LocallyFinite fun i => ball (c i) (r' i)) ∧ (⋃ i, ball (c i) (r i)) = univ :=
   let ⟨ι, c, r, r', hlt, hfin, hsub⟩ :=
-    exists_locallyFinite_subset_unionᵢ_ball_radius_lt isClosed_univ fun x _ => hR x
+    exists_locallyFinite_subset_iUnion_ball_radius_lt isClosed_univ fun x _ => hR x
   ⟨ι, c, r, r', fun i => (hlt i).2, hfin, univ_subset_iff.1 hsub⟩
-#align exists_locally_finite_Union_eq_ball_radius_lt exists_locallyFinite_unionᵢ_eq_ball_radius_lt
-
+#align exists_locally_finite_Union_eq_ball_radius_lt exists_locallyFinite_iUnion_eq_ball_radius_lt

Co-authored-by: Moritz Firsching <firsching@google.com>