analysis.normed.order.upper_lower ⟷ Mathlib.Analysis.Normed.Order.UpperLower

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

@@ -99,7 +99,7 @@ theorem IsUpperSet.mem_interior_of_forall_lt (hs : IsUpperSet s) (hx : x ∈ clo
   cases nonempty_fintype ι
   obtain ⟨ε, hε, hxy⟩ := Pi.exists_forall_pos_add_lt h
   obtain ⟨z, hz, hxz⟩ := Metric.mem_closure_iff.1 hx _ hε
-  rw [dist_pi_lt_iff hε] at hxz 
+  rw [dist_pi_lt_iff hε] at hxz
   have hyz : ∀ i, z i < y i :=
     by
     refine' fun i => (hxy _).trans_le' (sub_le_iff_le_add'.1 <| (le_abs_self _).trans _)
@@ -109,7 +109,7 @@ theorem IsUpperSet.mem_interior_of_forall_lt (hs : IsUpperSet s) (hx : x ∈ clo
   refine' mem_interior.2 ⟨ball y δ, _, is_open_ball, mem_ball_self hδ⟩
   rintro w hw
   refine' hs (fun i => _) hz
-  simp_rw [ball_pi _ hδ, Real.ball_eq_Ioo] at hw 
+  simp_rw [ball_pi _ hδ, Real.ball_eq_Ioo] at hw
   exact ((lt_sub_iff_add_lt.2 <| hyz _).trans (hw _ <| mem_univ _).1).le
 #align is_upper_set.mem_interior_of_forall_lt IsUpperSet.mem_interior_of_forall_lt
 -/
@@ -121,7 +121,7 @@ theorem IsLowerSet.mem_interior_of_forall_lt (hs : IsLowerSet s) (hx : x ∈ clo
   cases nonempty_fintype ι
   obtain ⟨ε, hε, hxy⟩ := Pi.exists_forall_pos_add_lt h
   obtain ⟨z, hz, hxz⟩ := Metric.mem_closure_iff.1 hx _ hε
-  rw [dist_pi_lt_iff hε] at hxz 
+  rw [dist_pi_lt_iff hε] at hxz
   have hyz : ∀ i, y i < z i :=
     by
     refine' fun i =>
@@ -132,7 +132,7 @@ theorem IsLowerSet.mem_interior_of_forall_lt (hs : IsLowerSet s) (hx : x ∈ clo
   refine' mem_interior.2 ⟨ball y δ, _, is_open_ball, mem_ball_self hδ⟩
   rintro w hw
   refine' hs (fun i => _) hz
-  simp_rw [ball_pi _ hδ, Real.ball_eq_Ioo] at hw 
+  simp_rw [ball_pi _ hδ, Real.ball_eq_Ioo] at hw
   exact ((hw _ <| mem_univ _).2.trans <| hyz _).le
 #align is_lower_set.mem_interior_of_forall_lt IsLowerSet.mem_interior_of_forall_lt
 -/
@@ -238,12 +238,12 @@ theorem IsUpperSet.exists_subset_ball (hs : IsUpperSet s) (hx : x ∈ closure s)
     ring_nf
   obtain ⟨y, hy, hxy⟩ := Metric.mem_closure_iff.1 hx _ (div_pos hδ zero_lt_four)
   refine' fun z hz => hs.mem_interior_of_forall_lt (subset_closure hy) fun i => _
-  rw [mem_closed_ball, dist_eq_norm'] at hz 
-  rw [dist_eq_norm] at hxy 
+  rw [mem_closed_ball, dist_eq_norm'] at hz
+  rw [dist_eq_norm] at hxy
   replace hxy := (norm_le_pi_norm _ i).trans hxy.le
   replace hz := (norm_le_pi_norm _ i).trans hz
-  dsimp at hxy hz 
-  rw [abs_sub_le_iff] at hxy hz 
+  dsimp at hxy hz
+  rw [abs_sub_le_iff] at hxy hz
   linarith
 #align is_upper_set.exists_subset_ball IsUpperSet.exists_subset_ball
 -/
@@ -259,12 +259,12 @@ theorem IsLowerSet.exists_subset_ball (hs : IsLowerSet s) (hx : x ∈ closure s)
     ring_nf
   obtain ⟨y, hy, hxy⟩ := Metric.mem_closure_iff.1 hx _ (div_pos hδ zero_lt_four)
   refine' fun z hz => hs.mem_interior_of_forall_lt (subset_closure hy) fun i => _
-  rw [mem_closed_ball, dist_eq_norm'] at hz 
-  rw [dist_eq_norm] at hxy 
+  rw [mem_closed_ball, dist_eq_norm'] at hz
+  rw [dist_eq_norm] at hxy
   replace hxy := (norm_le_pi_norm _ i).trans hxy.le
   replace hz := (norm_le_pi_norm _ i).trans hz
-  dsimp at hxy hz 
-  rw [abs_sub_le_iff] at hxy hz 
+  dsimp at hxy hz
+  rw [abs_sub_le_iff] at hxy hz
   linarith
 #align is_lower_set.exists_subset_ball IsLowerSet.exists_subset_ball
 -/
@@ -281,7 +281,7 @@ theorem IsAntichain.interior_eq_empty [Nonempty ι] (hs : IsAntichain (· ≤ ·
   cases nonempty_fintype ι
   refine' eq_empty_of_forall_not_mem fun x hx => _
   have hx' := interior_subset hx
-  rw [mem_interior_iff_mem_nhds, Metric.mem_nhds_iff] at hx 
+  rw [mem_interior_iff_mem_nhds, Metric.mem_nhds_iff] at hx
   obtain ⟨ε, hε, hx⟩ := hx
   refine' hs.not_lt hx' (hx _) (lt_add_of_pos_right _ (by positivity : 0 < const ι (ε / 2)))
   simpa [const, @pi_norm_const ι ℝ _ _ _ (ε / 2), abs_of_nonneg hε.lt.le]

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

@@ -275,6 +275,7 @@ section Finite
 
 variable [Finite ι] {s t : Set (ι → ℝ)} {a₁ a₂ b₁ b₂ x y : ι → ℝ} {δ : ℝ}
 
+#print IsAntichain.interior_eq_empty /-
 theorem IsAntichain.interior_eq_empty [Nonempty ι] (hs : IsAntichain (· ≤ ·) s) : interior s = ∅ :=
   by
   cases nonempty_fintype ι
@@ -285,6 +286,7 @@ theorem IsAntichain.interior_eq_empty [Nonempty ι] (hs : IsAntichain (· ≤ ·
   refine' hs.not_lt hx' (hx _) (lt_add_of_pos_right _ (by positivity : 0 < const ι (ε / 2)))
   simpa [const, @pi_norm_const ι ℝ _ _ _ (ε / 2), abs_of_nonneg hε.lt.le]
 #align is_antichain.interior_eq_empty IsAntichain.interior_eq_empty
+-/
 
 /-!
 #### Note

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

@@ -316,7 +316,7 @@ protected theorem IsClosed.lowerClosure (hs : IsClosed s) (hs' : BddAbove s) :
   cases nonempty_fintype ι
   refine' IsSeqClosed.isClosed fun f x hf hx => _
   choose g hg hfg using hf
-  haveI : BoundedGeNhdsClass ℝ := by infer_instance
+  haveI : BoundedGENhdsClass ℝ := by infer_instance
   obtain ⟨a, ha⟩ := hx.bdd_below_range
   obtain ⟨b, hb, φ, hφ, hbf⟩ :=
     tendsto_subseq_of_bounded (hs'.bounded_inter bddBelow_Ici) fun n =>

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

@@ -8,7 +8,7 @@ import Analysis.Normed.Group.Pointwise
 import Analysis.Normed.Order.Basic
 import Topology.Algebra.Order.UpperLower
 
-#align_import analysis.normed.order.upper_lower from "leanprover-community/mathlib"@"9a48a083b390d9b84a71efbdc4e8dfa26a687104"
+#align_import analysis.normed.order.upper_lower from "leanprover-community/mathlib"@"b1abe23ae96fef89ad30d9f4362c307f72a55010"
 
 /-!
 # Upper/lower/order-connected sets in normed groups
@@ -27,9 +27,11 @@ are measurable.
 
 open Function Metric Set
 
+open scoped Pointwise
+
 variable {α ι : Type _}
 
-section MetricSpace
+section NormedOrderedGroup
 
 variable [NormedOrderedGroup α] {s : Set α}
 
@@ -67,14 +69,28 @@ protected theorem IsLowerSet.cthickening' (hs : IsLowerSet s) (ε : ℝ) :
 #align is_lower_set.cthickening IsLowerSet.cthickening
 -/
 
-end MetricSpace
+@[to_additive upper_closure_interior_subset]
+theorem upperClosure_interior_subset' (s : Set α) :
+    (upperClosure (interior s) : Set α) ⊆ interior (upperClosure s) :=
+  upperClosure_min (interior_mono subset_upperClosure) (upperClosure s).upper.interior
+#align upper_closure_interior_subset' upperClosure_interior_subset'
+#align upper_closure_interior_subset upper_closure_interior_subset
+
+@[to_additive lower_closure_interior_subset]
+theorem lower_closure_interior_subset' (s : Set α) :
+    (upperClosure (interior s) : Set α) ⊆ interior (upperClosure s) :=
+  upperClosure_min (interior_mono subset_upperClosure) (upperClosure s).upper.interior
+#align lower_closure_interior_subset' lower_closure_interior_subset'
+#align lower_closure_interior_subset lower_closure_interior_subset
+
+end NormedOrderedGroup
 
 /-! ### `ℝⁿ` -/
 
 
 section Finite
 
-variable [Finite ι] {s : Set (ι → ℝ)} {x y : ι → ℝ} {δ : ℝ}
+variable [Finite ι] {s : Set (ι → ℝ)} {x y : ι → ℝ}
 
 #print IsUpperSet.mem_interior_of_forall_lt /-
 theorem IsUpperSet.mem_interior_of_forall_lt (hs : IsUpperSet s) (hx : x ∈ closure s)
@@ -125,7 +141,91 @@ end Finite
 
 section Fintype
 
-variable [Fintype ι] {s : Set (ι → ℝ)} {x y : ι → ℝ} {δ : ℝ}
+variable [Fintype ι] {s t : Set (ι → ℝ)} {a₁ a₂ b₁ b₂ x y : ι → ℝ} {δ : ℝ}
+
+-- TODO: Generalise those lemmas so that they also apply to `ℝ` and `euclidean_space ι ℝ`
+theorem dist_inf_sup (x y : ι → ℝ) : dist (x ⊓ y) (x ⊔ y) = dist x y :=
+  by
+  refine' congr_arg coe (Finset.sup_congr rfl fun i _ => _)
+  simp only [Real.nndist_eq', sup_eq_max, inf_eq_min, max_sub_min_eq_abs, Pi.inf_apply,
+    Pi.sup_apply, Real.nnabs_of_nonneg, abs_nonneg, Real.toNNReal_abs]
+#align dist_inf_sup dist_inf_sup
+
+theorem dist_mono_left : MonotoneOn (fun x => dist x y) (Ici y) :=
+  by
+  refine' fun y₁ hy₁ y₂ hy₂ hy => NNReal.coe_le_coe.2 (Finset.sup_mono_fun fun i _ => _)
+  rw [Real.nndist_eq, Real.nnabs_of_nonneg (sub_nonneg_of_le (‹y ≤ _› i : y i ≤ y₁ i)),
+    Real.nndist_eq, Real.nnabs_of_nonneg (sub_nonneg_of_le (‹y ≤ _› i : y i ≤ y₂ i))]
+  exact Real.toNNReal_mono (sub_le_sub_right (hy _) _)
+#align dist_mono_left dist_mono_left
+
+theorem dist_mono_right : MonotoneOn (dist x) (Ici x) := by
+  simpa only [dist_comm] using dist_mono_left
+#align dist_mono_right dist_mono_right
+
+theorem dist_anti_left : AntitoneOn (fun x => dist x y) (Iic y) :=
+  by
+  refine' fun y₁ hy₁ y₂ hy₂ hy => NNReal.coe_le_coe.2 (Finset.sup_mono_fun fun i _ => _)
+  rw [Real.nndist_eq', Real.nnabs_of_nonneg (sub_nonneg_of_le (‹_ ≤ y› i : y₂ i ≤ y i)),
+    Real.nndist_eq', Real.nnabs_of_nonneg (sub_nonneg_of_le (‹_ ≤ y› i : y₁ i ≤ y i))]
+  exact Real.toNNReal_mono (sub_le_sub_left (hy _) _)
+#align dist_anti_left dist_anti_left
+
+theorem dist_anti_right : AntitoneOn (dist x) (Iic x) := by
+  simpa only [dist_comm] using dist_anti_left
+#align dist_anti_right dist_anti_right
+
+theorem dist_le_dist_of_le (ha : a₂ ≤ a₁) (h₁ : a₁ ≤ b₁) (hb : b₁ ≤ b₂) : dist a₁ b₁ ≤ dist a₂ b₂ :=
+  (dist_mono_right h₁ (h₁.trans hb) hb).trans <|
+    dist_anti_left (ha.trans <| h₁.trans hb) (h₁.trans hb) ha
+#align dist_le_dist_of_le dist_le_dist_of_le
+
+protected theorem Bornology.IsBounded.bddBelow : Bounded s → BddBelow s :=
+  by
+  rintro ⟨r, hr⟩
+  obtain rfl | ⟨x, hx⟩ := s.eq_empty_or_nonempty
+  · exact bddBelow_empty
+  ·
+    exact
+      ⟨x - const _ r, fun y hy i =>
+        sub_le_comm.1 (abs_sub_le_iff.1 <| (dist_le_pi_dist _ _ _).trans <| hr _ hx _ hy).1⟩
+#align metric.bounded.bdd_below Bornology.IsBounded.bddBelow
+
+protected theorem Bornology.IsBounded.bddAbove : Bounded s → BddAbove s :=
+  by
+  rintro ⟨r, hr⟩
+  obtain rfl | ⟨x, hx⟩ := s.eq_empty_or_nonempty
+  · exact bddAbove_empty
+  ·
+    exact
+      ⟨x + const _ r, fun y hy i =>
+        sub_le_iff_le_add'.1 <|
+          (abs_sub_le_iff.1 <| (dist_le_pi_dist _ _ _).trans <| hr _ hx _ hy).2⟩
+#align metric.bounded.bdd_above Bornology.IsBounded.bddAbove
+
+protected theorem BddBelow.isBounded : BddBelow s → BddAbove s → Bounded s :=
+  by
+  rintro ⟨a, ha⟩ ⟨b, hb⟩
+  refine' ⟨dist a b, fun x hx y hy => _⟩
+  rw [← dist_inf_sup]
+  exact dist_le_dist_of_le (le_inf (ha hx) <| ha hy) inf_le_sup (sup_le (hb hx) <| hb hy)
+#align bdd_below.bounded BddBelow.isBounded
+
+protected theorem BddAbove.isBounded : BddAbove s → BddBelow s → Bounded s :=
+  flip BddBelow.isBounded
+#align bdd_above.bounded BddAbove.isBounded
+
+theorem isBounded_iff_bddBelow_bddAbove : Bounded s ↔ BddBelow s ∧ BddAbove s :=
+  ⟨fun h => ⟨h.BddBelow, h.BddAbove⟩, fun h => h.1.Bounded h.2⟩
+#align bounded_iff_bdd_below_bdd_above isBounded_iff_bddBelow_bddAbove
+
+theorem BddBelow.isBounded_inter (hs : BddBelow s) (ht : BddAbove t) : Bounded (s ∩ t) :=
+  (hs.mono <| inter_subset_left _ _).Bounded <| ht.mono <| inter_subset_right _ _
+#align bdd_below.bounded_inter BddBelow.isBounded_inter
+
+theorem BddAbove.isBounded_inter (hs : BddAbove s) (ht : BddBelow t) : Bounded (s ∩ t) :=
+  (hs.mono <| inter_subset_left _ _).Bounded <| ht.mono <| inter_subset_right _ _
+#align bdd_above.bounded_inter BddAbove.isBounded_inter
 
 #print IsUpperSet.exists_subset_ball /-
 theorem IsUpperSet.exists_subset_ball (hs : IsUpperSet s) (hx : x ∈ closure s) (hδ : 0 < δ) :
@@ -171,3 +271,84 @@ theorem IsLowerSet.exists_subset_ball (hs : IsLowerSet s) (hx : x ∈ closure s)
 
 end Fintype
 
+section Finite
+
+variable [Finite ι] {s t : Set (ι → ℝ)} {a₁ a₂ b₁ b₂ x y : ι → ℝ} {δ : ℝ}
+
+theorem IsAntichain.interior_eq_empty [Nonempty ι] (hs : IsAntichain (· ≤ ·) s) : interior s = ∅ :=
+  by
+  cases nonempty_fintype ι
+  refine' eq_empty_of_forall_not_mem fun x hx => _
+  have hx' := interior_subset hx
+  rw [mem_interior_iff_mem_nhds, Metric.mem_nhds_iff] at hx 
+  obtain ⟨ε, hε, hx⟩ := hx
+  refine' hs.not_lt hx' (hx _) (lt_add_of_pos_right _ (by positivity : 0 < const ι (ε / 2)))
+  simpa [const, @pi_norm_const ι ℝ _ _ _ (ε / 2), abs_of_nonneg hε.lt.le]
+#align is_antichain.interior_eq_empty IsAntichain.interior_eq_empty
+
+/-!
+#### Note
+
+The closure and frontier of an antichain might not be antichains. Take for example the union
+of the open segments from `(0, 2)` to `(1, 1)` and from `(2, 1)` to `(3, 0)`. `(1, 1)` and `(2, 1)`
+are comparable and both in the closure/frontier.
+-/
+
+
+protected theorem IsClosed.upperClosure (hs : IsClosed s) (hs' : BddBelow s) :
+    IsClosed (upperClosure s : Set (ι → ℝ)) :=
+  by
+  cases nonempty_fintype ι
+  refine' IsSeqClosed.isClosed fun f x hf hx => _
+  choose g hg hgf using hf
+  obtain ⟨a, ha⟩ := hx.bdd_above_range
+  obtain ⟨b, hb, φ, hφ, hbf⟩ :=
+    tendsto_subseq_of_bounded (hs'.bounded_inter bddAbove_Iic) fun n =>
+      ⟨hg n, (hgf _).trans <| ha <| mem_range_self _⟩
+  exact
+    ⟨b, closure_minimal (inter_subset_left _ _) hs hb,
+      le_of_tendsto_of_tendsto' hbf (hx.comp hφ.tendsto_at_top) fun _ => hgf _⟩
+#align is_closed.upper_closure IsClosed.upperClosure
+
+protected theorem IsClosed.lowerClosure (hs : IsClosed s) (hs' : BddAbove s) :
+    IsClosed (lowerClosure s : Set (ι → ℝ)) :=
+  by
+  cases nonempty_fintype ι
+  refine' IsSeqClosed.isClosed fun f x hf hx => _
+  choose g hg hfg using hf
+  haveI : BoundedGeNhdsClass ℝ := by infer_instance
+  obtain ⟨a, ha⟩ := hx.bdd_below_range
+  obtain ⟨b, hb, φ, hφ, hbf⟩ :=
+    tendsto_subseq_of_bounded (hs'.bounded_inter bddBelow_Ici) fun n =>
+      ⟨hg n, (ha <| mem_range_self _).trans <| hfg _⟩
+  exact
+    ⟨b, closure_minimal (inter_subset_left _ _) hs hb,
+      le_of_tendsto_of_tendsto' (hx.comp hφ.tendsto_at_top) hbf fun _ => hfg _⟩
+#align is_closed.lower_closure IsClosed.lowerClosure
+
+protected theorem IsClopen.upperClosure (hs : IsClopen s) (hs' : BddBelow s) :
+    IsClopen (upperClosure s : Set (ι → ℝ)) :=
+  ⟨hs.1.upperClosure, hs.2.upperClosure hs'⟩
+#align is_clopen.upper_closure IsClopen.upperClosure
+
+protected theorem IsClopen.lowerClosure (hs : IsClopen s) (hs' : BddAbove s) :
+    IsClopen (lowerClosure s : Set (ι → ℝ)) :=
+  ⟨hs.1.lowerClosure, hs.2.lowerClosure hs'⟩
+#align is_clopen.lower_closure IsClopen.lowerClosure
+
+theorem closure_upperClosure_comm (hs : BddBelow s) :
+    closure (upperClosure s : Set (ι → ℝ)) = upperClosure (closure s) :=
+  (closure_minimal (upperClosure_anti subset_closure) <|
+        isClosed_closure.upperClosure hs.closure).antisymm <|
+    upperClosure_min (closure_mono subset_upperClosure) (upperClosure s).upper.closure
+#align closure_upper_closure_comm closure_upperClosure_comm
+
+theorem closure_lowerClosure_comm (hs : BddAbove s) :
+    closure (lowerClosure s : Set (ι → ℝ)) = lowerClosure (closure s) :=
+  (closure_minimal (lowerClosure_mono subset_closure) <|
+        isClosed_closure.lowerClosure hs.closure).antisymm <|
+    lowerClosure_min (closure_mono subset_lowerClosure) (lowerClosure s).lower.closure
+#align closure_lower_closure_comm closure_lowerClosure_comm
+
+end Finite
+

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

@@ -3,10 +3,10 @@ Copyright (c) 2022 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 -/
-import Mathbin.Algebra.Order.Field.Pi
-import Mathbin.Analysis.Normed.Group.Pointwise
-import Mathbin.Analysis.Normed.Order.Basic
-import Mathbin.Topology.Algebra.Order.UpperLower
+import Algebra.Order.Field.Pi
+import Analysis.Normed.Group.Pointwise
+import Analysis.Normed.Order.Basic
+import Topology.Algebra.Order.UpperLower
 
 #align_import analysis.normed.order.upper_lower from "leanprover-community/mathlib"@"9a48a083b390d9b84a71efbdc4e8dfa26a687104"
 

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

@@ -2,17 +2,14 @@
 Copyright (c) 2022 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
-
-! This file was ported from Lean 3 source module analysis.normed.order.upper_lower
-! leanprover-community/mathlib commit 9a48a083b390d9b84a71efbdc4e8dfa26a687104
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Order.Field.Pi
 import Mathbin.Analysis.Normed.Group.Pointwise
 import Mathbin.Analysis.Normed.Order.Basic
 import Mathbin.Topology.Algebra.Order.UpperLower
 
+#align_import analysis.normed.order.upper_lower from "leanprover-community/mathlib"@"9a48a083b390d9b84a71efbdc4e8dfa26a687104"
+
 /-!
 # Upper/lower/order-connected sets in normed groups
 

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

@@ -79,6 +79,7 @@ section Finite
 
 variable [Finite ι] {s : Set (ι → ℝ)} {x y : ι → ℝ} {δ : ℝ}
 
+#print IsUpperSet.mem_interior_of_forall_lt /-
 theorem IsUpperSet.mem_interior_of_forall_lt (hs : IsUpperSet s) (hx : x ∈ closure s)
     (h : ∀ i, x i < y i) : y ∈ interior s :=
   by
@@ -98,7 +99,9 @@ theorem IsUpperSet.mem_interior_of_forall_lt (hs : IsUpperSet s) (hx : x ∈ clo
   simp_rw [ball_pi _ hδ, Real.ball_eq_Ioo] at hw 
   exact ((lt_sub_iff_add_lt.2 <| hyz _).trans (hw _ <| mem_univ _).1).le
 #align is_upper_set.mem_interior_of_forall_lt IsUpperSet.mem_interior_of_forall_lt
+-/
 
+#print IsLowerSet.mem_interior_of_forall_lt /-
 theorem IsLowerSet.mem_interior_of_forall_lt (hs : IsLowerSet s) (hx : x ∈ closure s)
     (h : ∀ i, y i < x i) : y ∈ interior s :=
   by
@@ -119,6 +122,7 @@ theorem IsLowerSet.mem_interior_of_forall_lt (hs : IsLowerSet s) (hx : x ∈ clo
   simp_rw [ball_pi _ hδ, Real.ball_eq_Ioo] at hw 
   exact ((hw _ <| mem_univ _).2.trans <| hyz _).le
 #align is_lower_set.mem_interior_of_forall_lt IsLowerSet.mem_interior_of_forall_lt
+-/
 
 end Finite
 
@@ -126,6 +130,7 @@ section Fintype
 
 variable [Fintype ι] {s : Set (ι → ℝ)} {x y : ι → ℝ} {δ : ℝ}
 
+#print IsUpperSet.exists_subset_ball /-
 theorem IsUpperSet.exists_subset_ball (hs : IsUpperSet s) (hx : x ∈ closure s) (hδ : 0 < δ) :
     ∃ y, closedBall y (δ / 4) ⊆ closedBall x δ ∧ closedBall y (δ / 4) ⊆ interior s :=
   by
@@ -144,7 +149,9 @@ theorem IsUpperSet.exists_subset_ball (hs : IsUpperSet s) (hx : x ∈ closure s)
   rw [abs_sub_le_iff] at hxy hz 
   linarith
 #align is_upper_set.exists_subset_ball IsUpperSet.exists_subset_ball
+-/
 
+#print IsLowerSet.exists_subset_ball /-
 theorem IsLowerSet.exists_subset_ball (hs : IsLowerSet s) (hx : x ∈ closure s) (hδ : 0 < δ) :
     ∃ y, closedBall y (δ / 4) ⊆ closedBall x δ ∧ closedBall y (δ / 4) ⊆ interior s :=
   by
@@ -163,6 +170,7 @@ theorem IsLowerSet.exists_subset_ball (hs : IsLowerSet s) (hx : x ∈ closure s)
   rw [abs_sub_le_iff] at hxy hz 
   linarith
 #align is_lower_set.exists_subset_ball IsLowerSet.exists_subset_ball
+-/
 
 end Fintype
 

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

@@ -85,7 +85,7 @@ theorem IsUpperSet.mem_interior_of_forall_lt (hs : IsUpperSet s) (hx : x ∈ clo
   cases nonempty_fintype ι
   obtain ⟨ε, hε, hxy⟩ := Pi.exists_forall_pos_add_lt h
   obtain ⟨z, hz, hxz⟩ := Metric.mem_closure_iff.1 hx _ hε
-  rw [dist_pi_lt_iff hε] at hxz
+  rw [dist_pi_lt_iff hε] at hxz 
   have hyz : ∀ i, z i < y i :=
     by
     refine' fun i => (hxy _).trans_le' (sub_le_iff_le_add'.1 <| (le_abs_self _).trans _)
@@ -95,7 +95,7 @@ theorem IsUpperSet.mem_interior_of_forall_lt (hs : IsUpperSet s) (hx : x ∈ clo
   refine' mem_interior.2 ⟨ball y δ, _, is_open_ball, mem_ball_self hδ⟩
   rintro w hw
   refine' hs (fun i => _) hz
-  simp_rw [ball_pi _ hδ, Real.ball_eq_Ioo] at hw
+  simp_rw [ball_pi _ hδ, Real.ball_eq_Ioo] at hw 
   exact ((lt_sub_iff_add_lt.2 <| hyz _).trans (hw _ <| mem_univ _).1).le
 #align is_upper_set.mem_interior_of_forall_lt IsUpperSet.mem_interior_of_forall_lt
 
@@ -105,7 +105,7 @@ theorem IsLowerSet.mem_interior_of_forall_lt (hs : IsLowerSet s) (hx : x ∈ clo
   cases nonempty_fintype ι
   obtain ⟨ε, hε, hxy⟩ := Pi.exists_forall_pos_add_lt h
   obtain ⟨z, hz, hxz⟩ := Metric.mem_closure_iff.1 hx _ hε
-  rw [dist_pi_lt_iff hε] at hxz
+  rw [dist_pi_lt_iff hε] at hxz 
   have hyz : ∀ i, y i < z i :=
     by
     refine' fun i =>
@@ -116,7 +116,7 @@ theorem IsLowerSet.mem_interior_of_forall_lt (hs : IsLowerSet s) (hx : x ∈ clo
   refine' mem_interior.2 ⟨ball y δ, _, is_open_ball, mem_ball_self hδ⟩
   rintro w hw
   refine' hs (fun i => _) hz
-  simp_rw [ball_pi _ hδ, Real.ball_eq_Ioo] at hw
+  simp_rw [ball_pi _ hδ, Real.ball_eq_Ioo] at hw 
   exact ((hw _ <| mem_univ _).2.trans <| hyz _).le
 #align is_lower_set.mem_interior_of_forall_lt IsLowerSet.mem_interior_of_forall_lt
 
@@ -136,12 +136,12 @@ theorem IsUpperSet.exists_subset_ball (hs : IsUpperSet s) (hx : x ∈ closure s)
     ring_nf
   obtain ⟨y, hy, hxy⟩ := Metric.mem_closure_iff.1 hx _ (div_pos hδ zero_lt_four)
   refine' fun z hz => hs.mem_interior_of_forall_lt (subset_closure hy) fun i => _
-  rw [mem_closed_ball, dist_eq_norm'] at hz
-  rw [dist_eq_norm] at hxy
+  rw [mem_closed_ball, dist_eq_norm'] at hz 
+  rw [dist_eq_norm] at hxy 
   replace hxy := (norm_le_pi_norm _ i).trans hxy.le
   replace hz := (norm_le_pi_norm _ i).trans hz
-  dsimp at hxy hz
-  rw [abs_sub_le_iff] at hxy hz
+  dsimp at hxy hz 
+  rw [abs_sub_le_iff] at hxy hz 
   linarith
 #align is_upper_set.exists_subset_ball IsUpperSet.exists_subset_ball
 
@@ -155,12 +155,12 @@ theorem IsLowerSet.exists_subset_ball (hs : IsLowerSet s) (hx : x ∈ closure s)
     ring_nf
   obtain ⟨y, hy, hxy⟩ := Metric.mem_closure_iff.1 hx _ (div_pos hδ zero_lt_four)
   refine' fun z hz => hs.mem_interior_of_forall_lt (subset_closure hy) fun i => _
-  rw [mem_closed_ball, dist_eq_norm'] at hz
-  rw [dist_eq_norm] at hxy
+  rw [mem_closed_ball, dist_eq_norm'] at hz 
+  rw [dist_eq_norm] at hxy 
   replace hxy := (norm_le_pi_norm _ i).trans hxy.le
   replace hz := (norm_le_pi_norm _ i).trans hz
-  dsimp at hxy hz
-  rw [abs_sub_le_iff] at hxy hz
+  dsimp at hxy hz 
+  rw [abs_sub_le_iff] at hxy hz 
   linarith
 #align is_lower_set.exists_subset_ball IsLowerSet.exists_subset_ball
 

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

@@ -36,31 +36,39 @@ section MetricSpace
 
 variable [NormedOrderedGroup α] {s : Set α}
 
+#print IsUpperSet.thickening' /-
 @[to_additive IsUpperSet.thickening]
 protected theorem IsUpperSet.thickening' (hs : IsUpperSet s) (ε : ℝ) :
     IsUpperSet (thickening ε s) := by rw [← ball_mul_one]; exact hs.mul_left
 #align is_upper_set.thickening' IsUpperSet.thickening'
 #align is_upper_set.thickening IsUpperSet.thickening
+-/
 
+#print IsLowerSet.thickening' /-
 @[to_additive IsLowerSet.thickening]
 protected theorem IsLowerSet.thickening' (hs : IsLowerSet s) (ε : ℝ) :
     IsLowerSet (thickening ε s) := by rw [← ball_mul_one]; exact hs.mul_left
 #align is_lower_set.thickening' IsLowerSet.thickening'
 #align is_lower_set.thickening IsLowerSet.thickening
+-/
 
+#print IsUpperSet.cthickening' /-
 @[to_additive IsUpperSet.cthickening]
 protected theorem IsUpperSet.cthickening' (hs : IsUpperSet s) (ε : ℝ) :
     IsUpperSet (cthickening ε s) := by rw [cthickening_eq_Inter_thickening''];
   exact isUpperSet_iInter₂ fun δ hδ => hs.thickening' _
 #align is_upper_set.cthickening' IsUpperSet.cthickening'
 #align is_upper_set.cthickening IsUpperSet.cthickening
+-/
 
+#print IsLowerSet.cthickening' /-
 @[to_additive IsLowerSet.cthickening]
 protected theorem IsLowerSet.cthickening' (hs : IsLowerSet s) (ε : ℝ) :
     IsLowerSet (cthickening ε s) := by rw [cthickening_eq_Inter_thickening''];
   exact isLowerSet_iInter₂ fun δ hδ => hs.thickening' _
 #align is_lower_set.cthickening' IsLowerSet.cthickening'
 #align is_lower_set.cthickening IsLowerSet.cthickening
+-/
 
 end MetricSpace
 

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

@@ -36,36 +36,18 @@ section MetricSpace
 
 variable [NormedOrderedGroup α] {s : Set α}
 
-/- warning: is_upper_set.thickening' -> IsUpperSet.thickening' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedOrderedGroup.{u1} α] {s : Set.{u1} α}, (IsUpperSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) s) -> (forall (ε : Real), IsUpperSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) (Metric.thickening.{u1} α (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α (SeminormedCommGroup.toPseudoMetricSpace.{u1} α (NormedCommGroup.toSeminormedCommGroup.{u1} α (NormedOrderedGroup.toNormedCommGroup.{u1} α _inst_1)))) ε s))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedOrderedGroup.{u1} α] {s : Set.{u1} α}, (IsUpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) s) -> (forall (ε : Real), IsUpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) (Metric.thickening.{u1} α (EMetricSpace.toPseudoEMetricSpace.{u1} α (MetricSpace.toEMetricSpace.{u1} α (NormedOrderedGroup.toMetricSpace.{u1} α _inst_1))) ε s))
-Case conversion may be inaccurate. Consider using '#align is_upper_set.thickening' IsUpperSet.thickening'ₓ'. -/
 @[to_additive IsUpperSet.thickening]
 protected theorem IsUpperSet.thickening' (hs : IsUpperSet s) (ε : ℝ) :
     IsUpperSet (thickening ε s) := by rw [← ball_mul_one]; exact hs.mul_left
 #align is_upper_set.thickening' IsUpperSet.thickening'
 #align is_upper_set.thickening IsUpperSet.thickening
 
-/- warning: is_lower_set.thickening' -> IsLowerSet.thickening' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedOrderedGroup.{u1} α] {s : Set.{u1} α}, (IsLowerSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) s) -> (forall (ε : Real), IsLowerSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) (Metric.thickening.{u1} α (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α (SeminormedCommGroup.toPseudoMetricSpace.{u1} α (NormedCommGroup.toSeminormedCommGroup.{u1} α (NormedOrderedGroup.toNormedCommGroup.{u1} α _inst_1)))) ε s))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedOrderedGroup.{u1} α] {s : Set.{u1} α}, (IsLowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) s) -> (forall (ε : Real), IsLowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) (Metric.thickening.{u1} α (EMetricSpace.toPseudoEMetricSpace.{u1} α (MetricSpace.toEMetricSpace.{u1} α (NormedOrderedGroup.toMetricSpace.{u1} α _inst_1))) ε s))
-Case conversion may be inaccurate. Consider using '#align is_lower_set.thickening' IsLowerSet.thickening'ₓ'. -/
 @[to_additive IsLowerSet.thickening]
 protected theorem IsLowerSet.thickening' (hs : IsLowerSet s) (ε : ℝ) :
     IsLowerSet (thickening ε s) := by rw [← ball_mul_one]; exact hs.mul_left
 #align is_lower_set.thickening' IsLowerSet.thickening'
 #align is_lower_set.thickening IsLowerSet.thickening
 
-/- warning: is_upper_set.cthickening' -> IsUpperSet.cthickening' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedOrderedGroup.{u1} α] {s : Set.{u1} α}, (IsUpperSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) s) -> (forall (ε : Real), IsUpperSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) (Metric.cthickening.{u1} α (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α (SeminormedCommGroup.toPseudoMetricSpace.{u1} α (NormedCommGroup.toSeminormedCommGroup.{u1} α (NormedOrderedGroup.toNormedCommGroup.{u1} α _inst_1)))) ε s))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedOrderedGroup.{u1} α] {s : Set.{u1} α}, (IsUpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) s) -> (forall (ε : Real), IsUpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) (Metric.cthickening.{u1} α (EMetricSpace.toPseudoEMetricSpace.{u1} α (MetricSpace.toEMetricSpace.{u1} α (NormedOrderedGroup.toMetricSpace.{u1} α _inst_1))) ε s))
-Case conversion may be inaccurate. Consider using '#align is_upper_set.cthickening' IsUpperSet.cthickening'ₓ'. -/
 @[to_additive IsUpperSet.cthickening]
 protected theorem IsUpperSet.cthickening' (hs : IsUpperSet s) (ε : ℝ) :
     IsUpperSet (cthickening ε s) := by rw [cthickening_eq_Inter_thickening''];
@@ -73,12 +55,6 @@ protected theorem IsUpperSet.cthickening' (hs : IsUpperSet s) (ε : ℝ) :
 #align is_upper_set.cthickening' IsUpperSet.cthickening'
 #align is_upper_set.cthickening IsUpperSet.cthickening
 
-/- warning: is_lower_set.cthickening' -> IsLowerSet.cthickening' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedOrderedGroup.{u1} α] {s : Set.{u1} α}, (IsLowerSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) s) -> (forall (ε : Real), IsLowerSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) (Metric.cthickening.{u1} α (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α (SeminormedCommGroup.toPseudoMetricSpace.{u1} α (NormedCommGroup.toSeminormedCommGroup.{u1} α (NormedOrderedGroup.toNormedCommGroup.{u1} α _inst_1)))) ε s))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedOrderedGroup.{u1} α] {s : Set.{u1} α}, (IsLowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) s) -> (forall (ε : Real), IsLowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) (Metric.cthickening.{u1} α (EMetricSpace.toPseudoEMetricSpace.{u1} α (MetricSpace.toEMetricSpace.{u1} α (NormedOrderedGroup.toMetricSpace.{u1} α _inst_1))) ε s))
-Case conversion may be inaccurate. Consider using '#align is_lower_set.cthickening' IsLowerSet.cthickening'ₓ'. -/
 @[to_additive IsLowerSet.cthickening]
 protected theorem IsLowerSet.cthickening' (hs : IsLowerSet s) (ε : ℝ) :
     IsLowerSet (cthickening ε s) := by rw [cthickening_eq_Inter_thickening''];
@@ -95,12 +71,6 @@ section Finite
 
 variable [Finite ι] {s : Set (ι → ℝ)} {x y : ι → ℝ} {δ : ℝ}
 
-/- warning: is_upper_set.mem_interior_of_forall_lt -> IsUpperSet.mem_interior_of_forall_lt is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {s : Set.{u1} (ι -> Real)} {x : ι -> Real} {y : ι -> Real}, (IsUpperSet.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.hasLe)) s) -> (Membership.Mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.hasMem.{u1} (ι -> Real)) x (closure.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s)) -> (forall (i : ι), LT.lt.{0} Real Real.hasLt (x i) (y i)) -> (Membership.Mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.hasMem.{u1} (ι -> Real)) y (interior.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {s : Set.{u1} (ι -> Real)} {x : ι -> Real} {y : ι -> Real}, (IsUpperSet.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.instLEReal)) s) -> (Membership.mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.instMembershipSet.{u1} (ι -> Real)) x (closure.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s)) -> (forall (i : ι), LT.lt.{0} Real Real.instLTReal (x i) (y i)) -> (Membership.mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.instMembershipSet.{u1} (ι -> Real)) y (interior.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s))
-Case conversion may be inaccurate. Consider using '#align is_upper_set.mem_interior_of_forall_lt IsUpperSet.mem_interior_of_forall_ltₓ'. -/
 theorem IsUpperSet.mem_interior_of_forall_lt (hs : IsUpperSet s) (hx : x ∈ closure s)
     (h : ∀ i, x i < y i) : y ∈ interior s :=
   by
@@ -121,12 +91,6 @@ theorem IsUpperSet.mem_interior_of_forall_lt (hs : IsUpperSet s) (hx : x ∈ clo
   exact ((lt_sub_iff_add_lt.2 <| hyz _).trans (hw _ <| mem_univ _).1).le
 #align is_upper_set.mem_interior_of_forall_lt IsUpperSet.mem_interior_of_forall_lt
 
-/- warning: is_lower_set.mem_interior_of_forall_lt -> IsLowerSet.mem_interior_of_forall_lt is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {s : Set.{u1} (ι -> Real)} {x : ι -> Real} {y : ι -> Real}, (IsLowerSet.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.hasLe)) s) -> (Membership.Mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.hasMem.{u1} (ι -> Real)) x (closure.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s)) -> (forall (i : ι), LT.lt.{0} Real Real.hasLt (y i) (x i)) -> (Membership.Mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.hasMem.{u1} (ι -> Real)) y (interior.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {s : Set.{u1} (ι -> Real)} {x : ι -> Real} {y : ι -> Real}, (IsLowerSet.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.instLEReal)) s) -> (Membership.mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.instMembershipSet.{u1} (ι -> Real)) x (closure.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s)) -> (forall (i : ι), LT.lt.{0} Real Real.instLTReal (y i) (x i)) -> (Membership.mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.instMembershipSet.{u1} (ι -> Real)) y (interior.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s))
-Case conversion may be inaccurate. Consider using '#align is_lower_set.mem_interior_of_forall_lt IsLowerSet.mem_interior_of_forall_ltₓ'. -/
 theorem IsLowerSet.mem_interior_of_forall_lt (hs : IsLowerSet s) (hx : x ∈ closure s)
     (h : ∀ i, y i < x i) : y ∈ interior s :=
   by
@@ -154,12 +118,6 @@ section Fintype
 
 variable [Fintype ι] {s : Set (ι → ℝ)} {x y : ι → ℝ} {δ : ℝ}
 
-/- warning: is_upper_set.exists_subset_ball -> IsUpperSet.exists_subset_ball is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {s : Set.{u1} (ι -> Real)} {x : ι -> Real} {δ : Real}, (IsUpperSet.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.hasLe)) s) -> (Membership.Mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.hasMem.{u1} (ι -> Real)) x (closure.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s)) -> (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (Exists.{succ u1} (ι -> Real) (fun (y : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} (ι -> Real)) (Set.hasSubset.{u1} (ι -> Real)) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) y (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) δ (OfNat.ofNat.{0} Real 4 (OfNat.mk.{0} Real 4 (bit0.{0} Real Real.hasAdd (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) x δ)) (HasSubset.Subset.{u1} (Set.{u1} (ι -> Real)) (Set.hasSubset.{u1} (ι -> Real)) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) y (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) δ (OfNat.ofNat.{0} Real 4 (OfNat.mk.{0} Real 4 (bit0.{0} Real Real.hasAdd (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (interior.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s))))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {s : Set.{u1} (ι -> Real)} {x : ι -> Real} {δ : Real}, (IsUpperSet.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.instLEReal)) s) -> (Membership.mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.instMembershipSet.{u1} (ι -> Real)) x (closure.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s)) -> (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (Exists.{succ u1} (ι -> Real) (fun (y : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} (ι -> Real)) (Set.instHasSubsetSet.{u1} (ι -> Real)) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) y (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) δ (OfNat.ofNat.{0} Real 4 (instOfNat.{0} Real 4 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))))))) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) x δ)) (HasSubset.Subset.{u1} (Set.{u1} (ι -> Real)) (Set.instHasSubsetSet.{u1} (ι -> Real)) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) y (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) δ (OfNat.ofNat.{0} Real 4 (instOfNat.{0} Real 4 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))))))) (interior.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s))))
-Case conversion may be inaccurate. Consider using '#align is_upper_set.exists_subset_ball IsUpperSet.exists_subset_ballₓ'. -/
 theorem IsUpperSet.exists_subset_ball (hs : IsUpperSet s) (hx : x ∈ closure s) (hδ : 0 < δ) :
     ∃ y, closedBall y (δ / 4) ⊆ closedBall x δ ∧ closedBall y (δ / 4) ⊆ interior s :=
   by
@@ -179,12 +137,6 @@ theorem IsUpperSet.exists_subset_ball (hs : IsUpperSet s) (hx : x ∈ closure s)
   linarith
 #align is_upper_set.exists_subset_ball IsUpperSet.exists_subset_ball
 
-/- warning: is_lower_set.exists_subset_ball -> IsLowerSet.exists_subset_ball is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {s : Set.{u1} (ι -> Real)} {x : ι -> Real} {δ : Real}, (IsLowerSet.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.hasLe)) s) -> (Membership.Mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.hasMem.{u1} (ι -> Real)) x (closure.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s)) -> (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (Exists.{succ u1} (ι -> Real) (fun (y : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} (ι -> Real)) (Set.hasSubset.{u1} (ι -> Real)) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) y (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) δ (OfNat.ofNat.{0} Real 4 (OfNat.mk.{0} Real 4 (bit0.{0} Real Real.hasAdd (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) x δ)) (HasSubset.Subset.{u1} (Set.{u1} (ι -> Real)) (Set.hasSubset.{u1} (ι -> Real)) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) y (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) δ (OfNat.ofNat.{0} Real 4 (OfNat.mk.{0} Real 4 (bit0.{0} Real Real.hasAdd (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (interior.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s))))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {s : Set.{u1} (ι -> Real)} {x : ι -> Real} {δ : Real}, (IsLowerSet.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.instLEReal)) s) -> (Membership.mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.instMembershipSet.{u1} (ι -> Real)) x (closure.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s)) -> (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (Exists.{succ u1} (ι -> Real) (fun (y : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} (ι -> Real)) (Set.instHasSubsetSet.{u1} (ι -> Real)) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) y (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) δ (OfNat.ofNat.{0} Real 4 (instOfNat.{0} Real 4 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))))))) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) x δ)) (HasSubset.Subset.{u1} (Set.{u1} (ι -> Real)) (Set.instHasSubsetSet.{u1} (ι -> Real)) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) y (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) δ (OfNat.ofNat.{0} Real 4 (instOfNat.{0} Real 4 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))))))) (interior.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s))))
-Case conversion may be inaccurate. Consider using '#align is_lower_set.exists_subset_ball IsLowerSet.exists_subset_ballₓ'. -/
 theorem IsLowerSet.exists_subset_ball (hs : IsLowerSet s) (hx : x ∈ closure s) (hδ : 0 < δ) :
     ∃ y, closedBall y (δ / 4) ⊆ closedBall x δ ∧ closedBall y (δ / 4) ⊆ interior s :=
   by

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

@@ -44,9 +44,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align is_upper_set.thickening' IsUpperSet.thickening'ₓ'. -/
 @[to_additive IsUpperSet.thickening]
 protected theorem IsUpperSet.thickening' (hs : IsUpperSet s) (ε : ℝ) :
-    IsUpperSet (thickening ε s) := by
-  rw [← ball_mul_one]
-  exact hs.mul_left
+    IsUpperSet (thickening ε s) := by rw [← ball_mul_one]; exact hs.mul_left
 #align is_upper_set.thickening' IsUpperSet.thickening'
 #align is_upper_set.thickening IsUpperSet.thickening
 
@@ -58,9 +56,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align is_lower_set.thickening' IsLowerSet.thickening'ₓ'. -/
 @[to_additive IsLowerSet.thickening]
 protected theorem IsLowerSet.thickening' (hs : IsLowerSet s) (ε : ℝ) :
-    IsLowerSet (thickening ε s) := by
-  rw [← ball_mul_one]
-  exact hs.mul_left
+    IsLowerSet (thickening ε s) := by rw [← ball_mul_one]; exact hs.mul_left
 #align is_lower_set.thickening' IsLowerSet.thickening'
 #align is_lower_set.thickening IsLowerSet.thickening
 
@@ -72,9 +68,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align is_upper_set.cthickening' IsUpperSet.cthickening'ₓ'. -/
 @[to_additive IsUpperSet.cthickening]
 protected theorem IsUpperSet.cthickening' (hs : IsUpperSet s) (ε : ℝ) :
-    IsUpperSet (cthickening ε s) :=
-  by
-  rw [cthickening_eq_Inter_thickening'']
+    IsUpperSet (cthickening ε s) := by rw [cthickening_eq_Inter_thickening''];
   exact isUpperSet_iInter₂ fun δ hδ => hs.thickening' _
 #align is_upper_set.cthickening' IsUpperSet.cthickening'
 #align is_upper_set.cthickening IsUpperSet.cthickening
@@ -87,9 +81,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align is_lower_set.cthickening' IsLowerSet.cthickening'ₓ'. -/
 @[to_additive IsLowerSet.cthickening]
 protected theorem IsLowerSet.cthickening' (hs : IsLowerSet s) (ε : ℝ) :
-    IsLowerSet (cthickening ε s) :=
-  by
-  rw [cthickening_eq_Inter_thickening'']
+    IsLowerSet (cthickening ε s) := by rw [cthickening_eq_Inter_thickening''];
   exact isLowerSet_iInter₂ fun δ hδ => hs.thickening' _
 #align is_lower_set.cthickening' IsLowerSet.cthickening'
 #align is_lower_set.cthickening IsLowerSet.cthickening

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

@@ -36,7 +36,12 @@ section MetricSpace
 
 variable [NormedOrderedGroup α] {s : Set α}
 
-#print IsUpperSet.thickening' /-
+/- warning: is_upper_set.thickening' -> IsUpperSet.thickening' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedOrderedGroup.{u1} α] {s : Set.{u1} α}, (IsUpperSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) s) -> (forall (ε : Real), IsUpperSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) (Metric.thickening.{u1} α (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α (SeminormedCommGroup.toPseudoMetricSpace.{u1} α (NormedCommGroup.toSeminormedCommGroup.{u1} α (NormedOrderedGroup.toNormedCommGroup.{u1} α _inst_1)))) ε s))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedOrderedGroup.{u1} α] {s : Set.{u1} α}, (IsUpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) s) -> (forall (ε : Real), IsUpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) (Metric.thickening.{u1} α (EMetricSpace.toPseudoEMetricSpace.{u1} α (MetricSpace.toEMetricSpace.{u1} α (NormedOrderedGroup.toMetricSpace.{u1} α _inst_1))) ε s))
+Case conversion may be inaccurate. Consider using '#align is_upper_set.thickening' IsUpperSet.thickening'ₓ'. -/
 @[to_additive IsUpperSet.thickening]
 protected theorem IsUpperSet.thickening' (hs : IsUpperSet s) (ε : ℝ) :
     IsUpperSet (thickening ε s) := by
@@ -44,9 +49,13 @@ protected theorem IsUpperSet.thickening' (hs : IsUpperSet s) (ε : ℝ) :
   exact hs.mul_left
 #align is_upper_set.thickening' IsUpperSet.thickening'
 #align is_upper_set.thickening IsUpperSet.thickening
--/
 
-#print IsLowerSet.thickening' /-
+/- warning: is_lower_set.thickening' -> IsLowerSet.thickening' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedOrderedGroup.{u1} α] {s : Set.{u1} α}, (IsLowerSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) s) -> (forall (ε : Real), IsLowerSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) (Metric.thickening.{u1} α (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α (SeminormedCommGroup.toPseudoMetricSpace.{u1} α (NormedCommGroup.toSeminormedCommGroup.{u1} α (NormedOrderedGroup.toNormedCommGroup.{u1} α _inst_1)))) ε s))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedOrderedGroup.{u1} α] {s : Set.{u1} α}, (IsLowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) s) -> (forall (ε : Real), IsLowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) (Metric.thickening.{u1} α (EMetricSpace.toPseudoEMetricSpace.{u1} α (MetricSpace.toEMetricSpace.{u1} α (NormedOrderedGroup.toMetricSpace.{u1} α _inst_1))) ε s))
+Case conversion may be inaccurate. Consider using '#align is_lower_set.thickening' IsLowerSet.thickening'ₓ'. -/
 @[to_additive IsLowerSet.thickening]
 protected theorem IsLowerSet.thickening' (hs : IsLowerSet s) (ε : ℝ) :
     IsLowerSet (thickening ε s) := by
@@ -54,9 +63,13 @@ protected theorem IsLowerSet.thickening' (hs : IsLowerSet s) (ε : ℝ) :
   exact hs.mul_left
 #align is_lower_set.thickening' IsLowerSet.thickening'
 #align is_lower_set.thickening IsLowerSet.thickening
--/
 
-#print IsUpperSet.cthickening' /-
+/- warning: is_upper_set.cthickening' -> IsUpperSet.cthickening' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedOrderedGroup.{u1} α] {s : Set.{u1} α}, (IsUpperSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) s) -> (forall (ε : Real), IsUpperSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) (Metric.cthickening.{u1} α (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α (SeminormedCommGroup.toPseudoMetricSpace.{u1} α (NormedCommGroup.toSeminormedCommGroup.{u1} α (NormedOrderedGroup.toNormedCommGroup.{u1} α _inst_1)))) ε s))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedOrderedGroup.{u1} α] {s : Set.{u1} α}, (IsUpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) s) -> (forall (ε : Real), IsUpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) (Metric.cthickening.{u1} α (EMetricSpace.toPseudoEMetricSpace.{u1} α (MetricSpace.toEMetricSpace.{u1} α (NormedOrderedGroup.toMetricSpace.{u1} α _inst_1))) ε s))
+Case conversion may be inaccurate. Consider using '#align is_upper_set.cthickening' IsUpperSet.cthickening'ₓ'. -/
 @[to_additive IsUpperSet.cthickening]
 protected theorem IsUpperSet.cthickening' (hs : IsUpperSet s) (ε : ℝ) :
     IsUpperSet (cthickening ε s) :=
@@ -65,9 +78,13 @@ protected theorem IsUpperSet.cthickening' (hs : IsUpperSet s) (ε : ℝ) :
   exact isUpperSet_iInter₂ fun δ hδ => hs.thickening' _
 #align is_upper_set.cthickening' IsUpperSet.cthickening'
 #align is_upper_set.cthickening IsUpperSet.cthickening
--/
 
-#print IsLowerSet.cthickening' /-
+/- warning: is_lower_set.cthickening' -> IsLowerSet.cthickening' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedOrderedGroup.{u1} α] {s : Set.{u1} α}, (IsLowerSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) s) -> (forall (ε : Real), IsLowerSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) (Metric.cthickening.{u1} α (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α (SeminormedCommGroup.toPseudoMetricSpace.{u1} α (NormedCommGroup.toSeminormedCommGroup.{u1} α (NormedOrderedGroup.toNormedCommGroup.{u1} α _inst_1)))) ε s))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedOrderedGroup.{u1} α] {s : Set.{u1} α}, (IsLowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) s) -> (forall (ε : Real), IsLowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (NormedOrderedGroup.toOrderedCommGroup.{u1} α _inst_1)))) (Metric.cthickening.{u1} α (EMetricSpace.toPseudoEMetricSpace.{u1} α (MetricSpace.toEMetricSpace.{u1} α (NormedOrderedGroup.toMetricSpace.{u1} α _inst_1))) ε s))
+Case conversion may be inaccurate. Consider using '#align is_lower_set.cthickening' IsLowerSet.cthickening'ₓ'. -/
 @[to_additive IsLowerSet.cthickening]
 protected theorem IsLowerSet.cthickening' (hs : IsLowerSet s) (ε : ℝ) :
     IsLowerSet (cthickening ε s) :=
@@ -76,7 +93,6 @@ protected theorem IsLowerSet.cthickening' (hs : IsLowerSet s) (ε : ℝ) :
   exact isLowerSet_iInter₂ fun δ hδ => hs.thickening' _
 #align is_lower_set.cthickening' IsLowerSet.cthickening'
 #align is_lower_set.cthickening IsLowerSet.cthickening
--/
 
 end MetricSpace
 

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

@@ -62,7 +62,7 @@ protected theorem IsUpperSet.cthickening' (hs : IsUpperSet s) (ε : ℝ) :
     IsUpperSet (cthickening ε s) :=
   by
   rw [cthickening_eq_Inter_thickening'']
-  exact isUpperSet_interᵢ₂ fun δ hδ => hs.thickening' _
+  exact isUpperSet_iInter₂ fun δ hδ => hs.thickening' _
 #align is_upper_set.cthickening' IsUpperSet.cthickening'
 #align is_upper_set.cthickening IsUpperSet.cthickening
 -/
@@ -73,7 +73,7 @@ protected theorem IsLowerSet.cthickening' (hs : IsLowerSet s) (ε : ℝ) :
     IsLowerSet (cthickening ε s) :=
   by
   rw [cthickening_eq_Inter_thickening'']
-  exact isLowerSet_interᵢ₂ fun δ hδ => hs.thickening' _
+  exact isLowerSet_iInter₂ fun δ hδ => hs.thickening' _
 #align is_lower_set.cthickening' IsLowerSet.cthickening'
 #align is_lower_set.cthickening IsLowerSet.cthickening
 -/

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 
 ! This file was ported from Lean 3 source module analysis.normed.order.upper_lower
-! leanprover-community/mathlib commit 992efbda6f85a5c9074375d3c7cb9764c64d8f72
+! leanprover-community/mathlib commit 9a48a083b390d9b84a71efbdc4e8dfa26a687104
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -16,6 +16,9 @@ import Mathbin.Topology.Algebra.Order.UpperLower
 /-!
 # Upper/lower/order-connected sets in normed groups
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 The topological closure and interior of an upper/lower/order-connected set is an
 upper/lower/order-connected set (with the notable exception of the closure of an order-connected
 set).

mathlib commit https://github.com/leanprover-community/mathlib/commit/039ef89bef6e58b32b62898dd48e9d1a4312bb65

@@ -33,6 +33,7 @@ section MetricSpace
 
 variable [NormedOrderedGroup α] {s : Set α}
 
+#print IsUpperSet.thickening' /-
 @[to_additive IsUpperSet.thickening]
 protected theorem IsUpperSet.thickening' (hs : IsUpperSet s) (ε : ℝ) :
     IsUpperSet (thickening ε s) := by
@@ -40,7 +41,9 @@ protected theorem IsUpperSet.thickening' (hs : IsUpperSet s) (ε : ℝ) :
   exact hs.mul_left
 #align is_upper_set.thickening' IsUpperSet.thickening'
 #align is_upper_set.thickening IsUpperSet.thickening
+-/
 
+#print IsLowerSet.thickening' /-
 @[to_additive IsLowerSet.thickening]
 protected theorem IsLowerSet.thickening' (hs : IsLowerSet s) (ε : ℝ) :
     IsLowerSet (thickening ε s) := by
@@ -48,7 +51,9 @@ protected theorem IsLowerSet.thickening' (hs : IsLowerSet s) (ε : ℝ) :
   exact hs.mul_left
 #align is_lower_set.thickening' IsLowerSet.thickening'
 #align is_lower_set.thickening IsLowerSet.thickening
+-/
 
+#print IsUpperSet.cthickening' /-
 @[to_additive IsUpperSet.cthickening]
 protected theorem IsUpperSet.cthickening' (hs : IsUpperSet s) (ε : ℝ) :
     IsUpperSet (cthickening ε s) :=
@@ -57,7 +62,9 @@ protected theorem IsUpperSet.cthickening' (hs : IsUpperSet s) (ε : ℝ) :
   exact isUpperSet_interᵢ₂ fun δ hδ => hs.thickening' _
 #align is_upper_set.cthickening' IsUpperSet.cthickening'
 #align is_upper_set.cthickening IsUpperSet.cthickening
+-/
 
+#print IsLowerSet.cthickening' /-
 @[to_additive IsLowerSet.cthickening]
 protected theorem IsLowerSet.cthickening' (hs : IsLowerSet s) (ε : ℝ) :
     IsLowerSet (cthickening ε s) :=
@@ -66,6 +73,7 @@ protected theorem IsLowerSet.cthickening' (hs : IsLowerSet s) (ε : ℝ) :
   exact isLowerSet_interᵢ₂ fun δ hδ => hs.thickening' _
 #align is_lower_set.cthickening' IsLowerSet.cthickening'
 #align is_lower_set.cthickening IsLowerSet.cthickening
+-/
 
 end MetricSpace
 
@@ -76,6 +84,12 @@ section Finite
 
 variable [Finite ι] {s : Set (ι → ℝ)} {x y : ι → ℝ} {δ : ℝ}
 
+/- warning: is_upper_set.mem_interior_of_forall_lt -> IsUpperSet.mem_interior_of_forall_lt is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {s : Set.{u1} (ι -> Real)} {x : ι -> Real} {y : ι -> Real}, (IsUpperSet.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.hasLe)) s) -> (Membership.Mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.hasMem.{u1} (ι -> Real)) x (closure.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s)) -> (forall (i : ι), LT.lt.{0} Real Real.hasLt (x i) (y i)) -> (Membership.Mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.hasMem.{u1} (ι -> Real)) y (interior.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {s : Set.{u1} (ι -> Real)} {x : ι -> Real} {y : ι -> Real}, (IsUpperSet.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.instLEReal)) s) -> (Membership.mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.instMembershipSet.{u1} (ι -> Real)) x (closure.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s)) -> (forall (i : ι), LT.lt.{0} Real Real.instLTReal (x i) (y i)) -> (Membership.mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.instMembershipSet.{u1} (ι -> Real)) y (interior.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s))
+Case conversion may be inaccurate. Consider using '#align is_upper_set.mem_interior_of_forall_lt IsUpperSet.mem_interior_of_forall_ltₓ'. -/
 theorem IsUpperSet.mem_interior_of_forall_lt (hs : IsUpperSet s) (hx : x ∈ closure s)
     (h : ∀ i, x i < y i) : y ∈ interior s :=
   by
@@ -96,6 +110,12 @@ theorem IsUpperSet.mem_interior_of_forall_lt (hs : IsUpperSet s) (hx : x ∈ clo
   exact ((lt_sub_iff_add_lt.2 <| hyz _).trans (hw _ <| mem_univ _).1).le
 #align is_upper_set.mem_interior_of_forall_lt IsUpperSet.mem_interior_of_forall_lt
 
+/- warning: is_lower_set.mem_interior_of_forall_lt -> IsLowerSet.mem_interior_of_forall_lt is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {s : Set.{u1} (ι -> Real)} {x : ι -> Real} {y : ι -> Real}, (IsLowerSet.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.hasLe)) s) -> (Membership.Mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.hasMem.{u1} (ι -> Real)) x (closure.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s)) -> (forall (i : ι), LT.lt.{0} Real Real.hasLt (y i) (x i)) -> (Membership.Mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.hasMem.{u1} (ι -> Real)) y (interior.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {s : Set.{u1} (ι -> Real)} {x : ι -> Real} {y : ι -> Real}, (IsLowerSet.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.instLEReal)) s) -> (Membership.mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.instMembershipSet.{u1} (ι -> Real)) x (closure.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s)) -> (forall (i : ι), LT.lt.{0} Real Real.instLTReal (y i) (x i)) -> (Membership.mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.instMembershipSet.{u1} (ι -> Real)) y (interior.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s))
+Case conversion may be inaccurate. Consider using '#align is_lower_set.mem_interior_of_forall_lt IsLowerSet.mem_interior_of_forall_ltₓ'. -/
 theorem IsLowerSet.mem_interior_of_forall_lt (hs : IsLowerSet s) (hx : x ∈ closure s)
     (h : ∀ i, y i < x i) : y ∈ interior s :=
   by
@@ -123,6 +143,12 @@ section Fintype
 
 variable [Fintype ι] {s : Set (ι → ℝ)} {x y : ι → ℝ} {δ : ℝ}
 
+/- warning: is_upper_set.exists_subset_ball -> IsUpperSet.exists_subset_ball is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {s : Set.{u1} (ι -> Real)} {x : ι -> Real} {δ : Real}, (IsUpperSet.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.hasLe)) s) -> (Membership.Mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.hasMem.{u1} (ι -> Real)) x (closure.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s)) -> (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (Exists.{succ u1} (ι -> Real) (fun (y : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} (ι -> Real)) (Set.hasSubset.{u1} (ι -> Real)) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) y (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) δ (OfNat.ofNat.{0} Real 4 (OfNat.mk.{0} Real 4 (bit0.{0} Real Real.hasAdd (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) x δ)) (HasSubset.Subset.{u1} (Set.{u1} (ι -> Real)) (Set.hasSubset.{u1} (ι -> Real)) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) y (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) δ (OfNat.ofNat.{0} Real 4 (OfNat.mk.{0} Real 4 (bit0.{0} Real Real.hasAdd (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (interior.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s))))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {s : Set.{u1} (ι -> Real)} {x : ι -> Real} {δ : Real}, (IsUpperSet.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.instLEReal)) s) -> (Membership.mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.instMembershipSet.{u1} (ι -> Real)) x (closure.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s)) -> (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (Exists.{succ u1} (ι -> Real) (fun (y : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} (ι -> Real)) (Set.instHasSubsetSet.{u1} (ι -> Real)) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) y (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) δ (OfNat.ofNat.{0} Real 4 (instOfNat.{0} Real 4 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))))))) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) x δ)) (HasSubset.Subset.{u1} (Set.{u1} (ι -> Real)) (Set.instHasSubsetSet.{u1} (ι -> Real)) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) y (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) δ (OfNat.ofNat.{0} Real 4 (instOfNat.{0} Real 4 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))))))) (interior.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s))))
+Case conversion may be inaccurate. Consider using '#align is_upper_set.exists_subset_ball IsUpperSet.exists_subset_ballₓ'. -/
 theorem IsUpperSet.exists_subset_ball (hs : IsUpperSet s) (hx : x ∈ closure s) (hδ : 0 < δ) :
     ∃ y, closedBall y (δ / 4) ⊆ closedBall x δ ∧ closedBall y (δ / 4) ⊆ interior s :=
   by
@@ -142,6 +168,12 @@ theorem IsUpperSet.exists_subset_ball (hs : IsUpperSet s) (hx : x ∈ closure s)
   linarith
 #align is_upper_set.exists_subset_ball IsUpperSet.exists_subset_ball
 
+/- warning: is_lower_set.exists_subset_ball -> IsLowerSet.exists_subset_ball is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {s : Set.{u1} (ι -> Real)} {x : ι -> Real} {δ : Real}, (IsLowerSet.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.hasLe)) s) -> (Membership.Mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.hasMem.{u1} (ι -> Real)) x (closure.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s)) -> (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (Exists.{succ u1} (ι -> Real) (fun (y : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} (ι -> Real)) (Set.hasSubset.{u1} (ι -> Real)) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) y (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) δ (OfNat.ofNat.{0} Real 4 (OfNat.mk.{0} Real 4 (bit0.{0} Real Real.hasAdd (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) x δ)) (HasSubset.Subset.{u1} (Set.{u1} (ι -> Real)) (Set.hasSubset.{u1} (ι -> Real)) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) y (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) δ (OfNat.ofNat.{0} Real 4 (OfNat.mk.{0} Real 4 (bit0.{0} Real Real.hasAdd (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (interior.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s))))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {s : Set.{u1} (ι -> Real)} {x : ι -> Real} {δ : Real}, (IsLowerSet.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.instLEReal)) s) -> (Membership.mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.instMembershipSet.{u1} (ι -> Real)) x (closure.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s)) -> (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (Exists.{succ u1} (ι -> Real) (fun (y : ι -> Real) => And (HasSubset.Subset.{u1} (Set.{u1} (ι -> Real)) (Set.instHasSubsetSet.{u1} (ι -> Real)) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) y (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) δ (OfNat.ofNat.{0} Real 4 (instOfNat.{0} Real 4 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))))))) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) x δ)) (HasSubset.Subset.{u1} (Set.{u1} (ι -> Real)) (Set.instHasSubsetSet.{u1} (ι -> Real)) (Metric.closedBall.{u1} (ι -> Real) (pseudoMetricSpacePi.{u1, 0} ι (fun (ᾰ : ι) => Real) _inst_1 (fun (a : ι) => Real.pseudoMetricSpace)) y (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) δ (OfNat.ofNat.{0} Real 4 (instOfNat.{0} Real 4 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))))))) (interior.{u1} (ι -> Real) (Pi.topologicalSpace.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (a : ι) => UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace))) s))))
+Case conversion may be inaccurate. Consider using '#align is_lower_set.exists_subset_ball IsLowerSet.exists_subset_ballₓ'. -/
 theorem IsLowerSet.exists_subset_ball (hs : IsLowerSet s) (hx : x ∈ closure s) (hδ : 0 < δ) :
     ∃ y, closedBall y (δ / 4) ⊆ closedBall x δ ∧ closedBall y (δ / 4) ⊆ interior s :=
   by

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

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -6,7 +6,8 @@ Authors: Yaël Dillies
 import Mathlib.Algebra.Order.Field.Pi
 import Mathlib.Analysis.Normed.Group.Pointwise
 import Mathlib.Analysis.Normed.Order.Basic
-import Mathlib.Topology.Algebra.Order.UpperLower
+import Mathlib.Algebra.Order.UpperLower
+import Mathlib.Data.Real.Sqrt
 
 #align_import analysis.normed.order.upper_lower from "leanprover-community/mathlib"@"992efbda6f85a5c9074375d3c7cb9764c64d8f72"
 

Removes nonterminal simps on lines looking like simp [...]

@@ -119,8 +119,8 @@ theorem IsUpperSet.exists_subset_ball (hs : IsUpperSet s) (hx : x ∈ closure s)
   refine' ⟨x + const _ (3 / 4 * δ), closedBall_subset_closedBall' _, _⟩
   · rw [dist_self_add_left]
     refine' (add_le_add_left (pi_norm_const_le <| 3 / 4 * δ) _).trans_eq _
-    simp [Real.norm_of_nonneg, hδ.le, zero_le_three]
-    simp [abs_of_pos, abs_of_pos hδ]
+    simp only [norm_mul, norm_div, Real.norm_eq_abs]
+    simp only [gt_iff_lt, zero_lt_three, abs_of_pos, zero_lt_four, abs_of_pos hδ]
     ring
   obtain ⟨y, hy, hxy⟩ := Metric.mem_closure_iff.1 hx _ (div_pos hδ zero_lt_four)
   refine' fun z hz => hs.mem_interior_of_forall_lt (subset_closure hy) fun i => _
@@ -138,7 +138,8 @@ theorem IsLowerSet.exists_subset_ball (hs : IsLowerSet s) (hx : x ∈ closure s)
   refine' ⟨x - const _ (3 / 4 * δ), closedBall_subset_closedBall' _, _⟩
   · rw [dist_self_sub_left]
     refine' (add_le_add_left (pi_norm_const_le <| 3 / 4 * δ) _).trans_eq _
-    simp [abs_of_pos, abs_of_pos hδ]
+    simp only [norm_mul, norm_div, Real.norm_eq_abs, gt_iff_lt, zero_lt_three, abs_of_pos,
+      zero_lt_four, abs_of_pos hδ]
     ring
   obtain ⟨y, hy, hxy⟩ := Metric.mem_closure_iff.1 hx _ (div_pos hδ zero_lt_four)
   refine' fun z hz => hs.mem_interior_of_forall_lt (subset_closure hy) fun i => _

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

This has nice performance benefits.

@@ -24,7 +24,7 @@ are measurable.
 
 open Function Metric Set
 
-variable {α ι : Type _}
+variable {α ι : Type*}
 
 section MetricSpace
 

• depends on: #5966

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

@@ -2,17 +2,14 @@
 Copyright (c) 2022 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
-
-! This file was ported from Lean 3 source module analysis.normed.order.upper_lower
-! leanprover-community/mathlib commit 992efbda6f85a5c9074375d3c7cb9764c64d8f72
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Order.Field.Pi
 import Mathlib.Analysis.Normed.Group.Pointwise
 import Mathlib.Analysis.Normed.Order.Basic
 import Mathlib.Topology.Algebra.Order.UpperLower
 
+#align_import analysis.normed.order.upper_lower from "leanprover-community/mathlib"@"992efbda6f85a5c9074375d3c7cb9764c64d8f72"
+
 /-!
 # Upper/lower/order-connected sets in normed groups
 

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>

@@ -52,16 +52,16 @@ protected theorem IsLowerSet.thickening' (hs : IsLowerSet s) (ε : ℝ) :
 @[to_additive IsUpperSet.cthickening]
 protected theorem IsUpperSet.cthickening' (hs : IsUpperSet s) (ε : ℝ) :
     IsUpperSet (cthickening ε s) := by
-  rw [cthickening_eq_interᵢ_thickening'']
-  exact isUpperSet_interᵢ₂ fun δ _ => hs.thickening' _
+  rw [cthickening_eq_iInter_thickening'']
+  exact isUpperSet_iInter₂ fun δ _ => hs.thickening' _
 #align is_upper_set.cthickening' IsUpperSet.cthickening'
 #align is_upper_set.cthickening IsUpperSet.cthickening
 
 @[to_additive IsLowerSet.cthickening]
 protected theorem IsLowerSet.cthickening' (hs : IsLowerSet s) (ε : ℝ) :
     IsLowerSet (cthickening ε s) := by
-  rw [cthickening_eq_interᵢ_thickening'']
-  exact isLowerSet_interᵢ₂ fun δ _ => hs.thickening' _
+  rw [cthickening_eq_iInter_thickening'']
+  exact isLowerSet_iInter₂ fun δ _ => hs.thickening' _
 #align is_lower_set.cthickening' IsLowerSet.cthickening'
 #align is_lower_set.cthickening IsLowerSet.cthickening
 

Enable the cancelDenoms preprocessor in linarith. Closes #2714.

• depends on: #3797

Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: Patrick Massot <patrickmassot@free.fr> Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -133,16 +133,7 @@ theorem IsUpperSet.exists_subset_ball (hs : IsUpperSet s) (hx : x ∈ closure s)
   replace hz := (norm_le_pi_norm _ i).trans hz
   dsimp at hxy hz
   rw [abs_sub_le_iff] at hxy hz
-  -- Porting note: rest of proof was just `linarith`. Probably mathlib4#2714
-  have hxz : x i - z i ≤ -2 / 4 * δ := by
-    have h3 : -2 / 4 * δ - δ / 4 = -(3 / 4 * δ) := by ring
-    linarith
-  have hyz : y i - z i ≤ -δ / 4 := by
-    have t := add_le_add hxy.2 hxz
-    have h1 : δ / 4 + -2 / 4 * δ = -δ / 4 := by ring
-    linarith
-  have hδ4 : -δ / 4 < 0 := div_neg_of_neg_of_pos (Left.neg_neg_iff.mpr hδ) zero_lt_four
-  exact sub_neg.mp (lt_of_le_of_lt hyz hδ4)
+  linarith
 #align is_upper_set.exists_subset_ball IsUpperSet.exists_subset_ball
 
 theorem IsLowerSet.exists_subset_ball (hs : IsLowerSet s) (hx : x ∈ closure s) (hδ : 0 < δ) :
@@ -160,16 +151,7 @@ theorem IsLowerSet.exists_subset_ball (hs : IsLowerSet s) (hx : x ∈ closure s)
   replace hz := (norm_le_pi_norm _ i).trans hz
   dsimp at hxy hz
   rw [abs_sub_le_iff] at hxy hz
-  -- Porting note: rest of proof was just `linarith`. Probably mathlib4#2714
-  have hzx : z i - x i ≤ -2 / 4 * δ := by
-    have h3 : -2 / 4 * δ - δ / 4 = -(3 / 4 * δ) := by ring
-    linarith
-  have hzy : z i - y i ≤ -δ / 4 := by
-    have t := add_le_add hzx hxy.1
-    have h1 : -2 / 4 * δ + δ / 4 = -δ / 4 := by ring
-    linarith
-  have hδ4 : -δ / 4 < 0 := div_neg_of_neg_of_pos (Left.neg_neg_iff.mpr hδ) zero_lt_four
-  exact sub_neg.mp (lt_of_le_of_lt hzy hδ4)
+  linarith
 #align is_lower_set.exists_subset_ball IsLowerSet.exists_subset_ball
 
 end Fintype

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