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

@@ -3,7 +3,7 @@ Copyright (c) 2022 Kalle Kytölä. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kalle Kytölä
 -/
-import Data.Real.Ennreal
+import Data.ENNReal.Basic
 import Topology.ContinuousFunction.Bounded
 import Topology.MetricSpace.HausdorffDistance
 

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

@@ -113,11 +113,11 @@ theorem thickenedIndicatorAux_one_of_mem_closure (δ : ℝ) (E : Set α) {x : α
 theorem thickenedIndicatorAux_zero {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : α}
     (x_out : x ∉ thickening δ E) : thickenedIndicatorAux δ E x = 0 :=
   by
-  rw [thickening, mem_set_of_eq, not_lt] at x_out 
+  rw [thickening, mem_set_of_eq, not_lt] at x_out
   unfold thickenedIndicatorAux
   apply le_antisymm _ bot_le
   have key := tsub_le_tsub (@rfl _ (1 : ℝ≥0∞)).le (ENNReal.div_le_div x_out rfl.le)
-  rw [ENNReal.div_self (ne_of_gt (ennreal.of_real_pos.mpr δ_pos)) of_real_ne_top] at key 
+  rw [ENNReal.div_self (ne_of_gt (ennreal.of_real_pos.mpr δ_pos)) of_real_ne_top] at key
   simpa using key
 #align thickened_indicator_aux_zero thickenedIndicatorAux_zero
 -/
@@ -170,9 +170,9 @@ theorem thickenedIndicatorAux_tendsto_indicator_closure {δseq : ℕ → ℝ}
   · rw [show (closure E).indicator (fun _ => (1 : ℝ≥0∞)) x = 0 by
         simp only [x_mem_closure, indicator_of_not_mem, not_false_iff]]
     rcases exists_real_pos_lt_inf_edist_of_not_mem_closure x_mem_closure with ⟨ε, ⟨ε_pos, ε_lt⟩⟩
-    rw [Metric.tendsto_nhds] at δseq_lim 
+    rw [Metric.tendsto_nhds] at δseq_lim
     specialize δseq_lim ε ε_pos
-    simp only [dist_zero_right, Real.norm_eq_abs, eventually_at_top, ge_iff_le] at δseq_lim 
+    simp only [dist_zero_right, Real.norm_eq_abs, eventually_at_top, ge_iff_le] at δseq_lim
     rcases δseq_lim with ⟨N, hN⟩
     apply @tendsto_atTop_of_eventually_const _ _ _ _ _ _ _ N
     intro n n_large

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

@@ -3,9 +3,9 @@ Copyright (c) 2022 Kalle Kytölä. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kalle Kytölä
 -/
-import Mathbin.Data.Real.Ennreal
-import Mathbin.Topology.ContinuousFunction.Bounded
-import Mathbin.Topology.MetricSpace.HausdorffDistance
+import Data.Real.Ennreal
+import Topology.ContinuousFunction.Bounded
+import Topology.MetricSpace.HausdorffDistance
 
 #align_import topology.metric_space.thickened_indicator from "leanprover-community/mathlib"@"38df578a6450a8c5142b3727e3ae894c2300cae0"
 

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

@@ -2,16 +2,13 @@
 Copyright (c) 2022 Kalle Kytölä. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kalle Kytölä
-
-! This file was ported from Lean 3 source module topology.metric_space.thickened_indicator
-! leanprover-community/mathlib commit 38df578a6450a8c5142b3727e3ae894c2300cae0
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Real.Ennreal
 import Mathbin.Topology.ContinuousFunction.Bounded
 import Mathbin.Topology.MetricSpace.HausdorffDistance
 
+#align_import topology.metric_space.thickened_indicator from "leanprover-community/mathlib"@"38df578a6450a8c5142b3727e3ae894c2300cae0"
+
 /-!
 # Thickened indicators
 

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

@@ -64,6 +64,7 @@ def thickenedIndicatorAux (δ : ℝ) (E : Set α) : α → ℝ≥0∞ := fun x :
 #align thickened_indicator_aux thickenedIndicatorAux
 -/
 
+#print continuous_thickenedIndicatorAux /-
 theorem continuous_thickenedIndicatorAux {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) :
     Continuous (thickenedIndicatorAux δ E) :=
   by
@@ -75,15 +76,20 @@ theorem continuous_thickenedIndicatorAux {δ : ℝ} (δ_pos : 0 < δ) (E : Set 
   apply (ENNReal.continuous_div_const (ENNReal.ofReal δ) _).comp continuous_inf_edist
   norm_num [δ_pos]
 #align continuous_thickened_indicator_aux continuous_thickenedIndicatorAux
+-/
 
+#print thickenedIndicatorAux_le_one /-
 theorem thickenedIndicatorAux_le_one (δ : ℝ) (E : Set α) (x : α) :
     thickenedIndicatorAux δ E x ≤ 1 := by apply @tsub_le_self _ _ _ _ (1 : ℝ≥0∞)
 #align thickened_indicator_aux_le_one thickenedIndicatorAux_le_one
+-/
 
+#print thickenedIndicatorAux_lt_top /-
 theorem thickenedIndicatorAux_lt_top {δ : ℝ} {E : Set α} {x : α} :
     thickenedIndicatorAux δ E x < ∞ :=
   lt_of_le_of_lt (thickenedIndicatorAux_le_one _ _ _) one_lt_top
 #align thickened_indicator_aux_lt_top thickenedIndicatorAux_lt_top
+-/
 
 #print thickenedIndicatorAux_closure_eq /-
 theorem thickenedIndicatorAux_closure_eq (δ : ℝ) (E : Set α) :
@@ -106,6 +112,7 @@ theorem thickenedIndicatorAux_one_of_mem_closure (δ : ℝ) (E : Set α) {x : α
 #align thickened_indicator_aux_one_of_mem_closure thickenedIndicatorAux_one_of_mem_closure
 -/
 
+#print thickenedIndicatorAux_zero /-
 theorem thickenedIndicatorAux_zero {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : α}
     (x_out : x ∉ thickening δ E) : thickenedIndicatorAux δ E x = 0 :=
   by
@@ -116,12 +123,16 @@ theorem thickenedIndicatorAux_zero {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x
   rw [ENNReal.div_self (ne_of_gt (ennreal.of_real_pos.mpr δ_pos)) of_real_ne_top] at key 
   simpa using key
 #align thickened_indicator_aux_zero thickenedIndicatorAux_zero
+-/
 
+#print thickenedIndicatorAux_mono /-
 theorem thickenedIndicatorAux_mono {δ₁ δ₂ : ℝ} (hle : δ₁ ≤ δ₂) (E : Set α) :
     thickenedIndicatorAux δ₁ E ≤ thickenedIndicatorAux δ₂ E := fun _ =>
   tsub_le_tsub (@rfl ℝ≥0∞ 1).le (ENNReal.div_le_div rfl.le (ofReal_le_ofReal hle))
 #align thickened_indicator_aux_mono thickenedIndicatorAux_mono
+-/
 
+#print indicator_le_thickenedIndicatorAux /-
 theorem indicator_le_thickenedIndicatorAux (δ : ℝ) (E : Set α) :
     (E.indicator fun _ => (1 : ℝ≥0∞)) ≤ thickenedIndicatorAux δ E :=
   by
@@ -130,12 +141,16 @@ theorem indicator_le_thickenedIndicatorAux (δ : ℝ) (E : Set α) :
   · simp only [h, indicator_of_mem, thickenedIndicatorAux_one δ E h, le_refl]
   · simp only [h, indicator_of_not_mem, not_false_iff, zero_le]
 #align indicator_le_thickened_indicator_aux indicator_le_thickenedIndicatorAux
+-/
 
+#print thickenedIndicatorAux_subset /-
 theorem thickenedIndicatorAux_subset (δ : ℝ) {E₁ E₂ : Set α} (subset : E₁ ⊆ E₂) :
     thickenedIndicatorAux δ E₁ ≤ thickenedIndicatorAux δ E₂ := fun _ =>
   tsub_le_tsub (@rfl ℝ≥0∞ 1).le (ENNReal.div_le_div (infEdist_anti subset) rfl.le)
 #align thickened_indicator_aux_subset thickenedIndicatorAux_subset
+-/
 
+#print thickenedIndicatorAux_tendsto_indicator_closure /-
 /-- As the thickening radius δ tends to 0, the δ-thickened indicator of a set E (in α) tends
 pointwise (i.e., w.r.t. the product topology on `α → ℝ≥0∞`) to the indicator function of the
 closure of E.
@@ -169,7 +184,9 @@ theorem thickenedIndicatorAux_tendsto_indicator_closure {δseq : ℕ → ℝ}
     apply (thickenedIndicatorAux_mono (lt_of_abs_lt (hN n n_large)).le E x).trans
     exact (thickenedIndicatorAux_zero ε_pos E key).le
 #align thickened_indicator_aux_tendsto_indicator_closure thickenedIndicatorAux_tendsto_indicator_closure
+-/
 
+#print thickenedIndicator /-
 /-- The `δ`-thickened indicator of a set `E` is the function that equals `1` on `E`
 and `0` outside a `δ`-thickening of `E` and interpolates (continuously) between
 these values using `inf_edist _ E`.
@@ -199,12 +216,16 @@ def thickenedIndicator {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) : α →ᵇ ℝ
         refine'
           (to_nnreal_le_to_nnreal (lt_of_le_of_lt (key _) one_lt_top).Ne one_ne_top).mpr (key _)
 #align thickened_indicator thickenedIndicator
+-/
 
+#print thickenedIndicator.coeFn_eq_comp /-
 theorem thickenedIndicator.coeFn_eq_comp {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) :
     ⇑(thickenedIndicator δ_pos E) = ENNReal.toNNReal ∘ thickenedIndicatorAux δ E :=
   rfl
 #align thickened_indicator.coe_fn_eq_comp thickenedIndicator.coeFn_eq_comp
+-/
 
+#print thickenedIndicator_le_one /-
 theorem thickenedIndicator_le_one {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) (x : α) :
     thickenedIndicator δ_pos E x ≤ 1 :=
   by
@@ -213,22 +234,30 @@ theorem thickenedIndicator_le_one {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) (x :
     (to_nnreal_le_to_nnreal thickened_indicator_aux_lt_top.ne one_ne_top).mpr
       (thickenedIndicatorAux_le_one δ E x)
 #align thickened_indicator_le_one thickenedIndicator_le_one
+-/
 
+#print thickenedIndicator_one_of_mem_closure /-
 theorem thickenedIndicator_one_of_mem_closure {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : α}
     (x_mem : x ∈ closure E) : thickenedIndicator δ_pos E x = 1 := by
   rw [thickenedIndicator_apply, thickenedIndicatorAux_one_of_mem_closure δ E x_mem, one_to_nnreal]
 #align thickened_indicator_one_of_mem_closure thickenedIndicator_one_of_mem_closure
+-/
 
+#print thickenedIndicator_one /-
 theorem thickenedIndicator_one {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : α} (x_in_E : x ∈ E) :
     thickenedIndicator δ_pos E x = 1 :=
   thickenedIndicator_one_of_mem_closure _ _ (subset_closure x_in_E)
 #align thickened_indicator_one thickenedIndicator_one
+-/
 
+#print thickenedIndicator_zero /-
 theorem thickenedIndicator_zero {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : α}
     (x_out : x ∉ thickening δ E) : thickenedIndicator δ_pos E x = 0 := by
   rw [thickenedIndicator_apply, thickenedIndicatorAux_zero δ_pos E x_out, zero_to_nnreal]
 #align thickened_indicator_zero thickenedIndicator_zero
+-/
 
+#print indicator_le_thickenedIndicator /-
 theorem indicator_le_thickenedIndicator {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) :
     (E.indicator fun _ => (1 : ℝ≥0)) ≤ thickenedIndicator δ_pos E :=
   by
@@ -237,7 +266,9 @@ theorem indicator_le_thickenedIndicator {δ : ℝ} (δ_pos : 0 < δ) (E : Set α
   · simp only [h, indicator_of_mem, thickenedIndicator_one δ_pos E h, le_refl]
   · simp only [h, indicator_of_not_mem, not_false_iff, zero_le]
 #align indicator_le_thickened_indicator indicator_le_thickenedIndicator
+-/
 
+#print thickenedIndicator_mono /-
 theorem thickenedIndicator_mono {δ₁ δ₂ : ℝ} (δ₁_pos : 0 < δ₁) (δ₂_pos : 0 < δ₂) (hle : δ₁ ≤ δ₂)
     (E : Set α) : ⇑(thickenedIndicator δ₁_pos E) ≤ thickenedIndicator δ₂_pos E :=
   by
@@ -246,13 +277,17 @@ theorem thickenedIndicator_mono {δ₁ δ₂ : ℝ} (δ₁_pos : 0 < δ₁) (δ
     (to_nnreal_le_to_nnreal thickened_indicator_aux_lt_top.ne thickened_indicator_aux_lt_top.ne).mpr
   apply thickenedIndicatorAux_mono hle
 #align thickened_indicator_mono thickenedIndicator_mono
+-/
 
+#print thickenedIndicator_subset /-
 theorem thickenedIndicator_subset {δ : ℝ} (δ_pos : 0 < δ) {E₁ E₂ : Set α} (subset : E₁ ⊆ E₂) :
     ⇑(thickenedIndicator δ_pos E₁) ≤ thickenedIndicator δ_pos E₂ := fun x =>
   (toNNReal_le_toNNReal thickenedIndicatorAux_lt_top.Ne thickenedIndicatorAux_lt_top.Ne).mpr
     (thickenedIndicatorAux_subset δ subset x)
 #align thickened_indicator_subset thickenedIndicator_subset
+-/
 
+#print thickenedIndicator_tendsto_indicator_closure /-
 /-- As the thickening radius δ tends to 0, the δ-thickened indicator of a set E (in α) tends
 pointwise to the indicator function of the closure of E.
 
@@ -274,6 +309,7 @@ theorem thickenedIndicator_tendsto_indicator_closure {δseq : ℕ → ℝ} (δse
   refine' tendsto.comp (tendsto_to_nnreal _) (key x)
   by_cases x_mem : x ∈ closure E <;> simp [x_mem]
 #align thickened_indicator_tendsto_indicator_closure thickenedIndicator_tendsto_indicator_closure
+-/
 
 end thickenedIndicator
 

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

@@ -109,11 +109,11 @@ theorem thickenedIndicatorAux_one_of_mem_closure (δ : ℝ) (E : Set α) {x : α
 theorem thickenedIndicatorAux_zero {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : α}
     (x_out : x ∉ thickening δ E) : thickenedIndicatorAux δ E x = 0 :=
   by
-  rw [thickening, mem_set_of_eq, not_lt] at x_out
+  rw [thickening, mem_set_of_eq, not_lt] at x_out 
   unfold thickenedIndicatorAux
   apply le_antisymm _ bot_le
   have key := tsub_le_tsub (@rfl _ (1 : ℝ≥0∞)).le (ENNReal.div_le_div x_out rfl.le)
-  rw [ENNReal.div_self (ne_of_gt (ennreal.of_real_pos.mpr δ_pos)) of_real_ne_top] at key
+  rw [ENNReal.div_self (ne_of_gt (ennreal.of_real_pos.mpr δ_pos)) of_real_ne_top] at key 
   simpa using key
 #align thickened_indicator_aux_zero thickenedIndicatorAux_zero
 
@@ -158,9 +158,9 @@ theorem thickenedIndicatorAux_tendsto_indicator_closure {δseq : ℕ → ℝ}
   · rw [show (closure E).indicator (fun _ => (1 : ℝ≥0∞)) x = 0 by
         simp only [x_mem_closure, indicator_of_not_mem, not_false_iff]]
     rcases exists_real_pos_lt_inf_edist_of_not_mem_closure x_mem_closure with ⟨ε, ⟨ε_pos, ε_lt⟩⟩
-    rw [Metric.tendsto_nhds] at δseq_lim
+    rw [Metric.tendsto_nhds] at δseq_lim 
     specialize δseq_lim ε ε_pos
-    simp only [dist_zero_right, Real.norm_eq_abs, eventually_at_top, ge_iff_le] at δseq_lim
+    simp only [dist_zero_right, Real.norm_eq_abs, eventually_at_top, ge_iff_le] at δseq_lim 
     rcases δseq_lim with ⟨N, hN⟩
     apply @tendsto_atTop_of_eventually_const _ _ _ _ _ _ _ N
     intro n n_large

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

@@ -44,7 +44,7 @@ members of the approximating sequence are nonnegative bounded continuous functio
 
 noncomputable section
 
-open Classical NNReal ENNReal Topology BoundedContinuousFunction
+open scoped Classical NNReal ENNReal Topology BoundedContinuousFunction
 
 open NNReal ENNReal Set Metric Emetric Filter
 

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

@@ -64,12 +64,6 @@ def thickenedIndicatorAux (δ : ℝ) (E : Set α) : α → ℝ≥0∞ := fun x :
 #align thickened_indicator_aux thickenedIndicatorAux
 -/
 
-/- warning: continuous_thickened_indicator_aux -> continuous_thickenedIndicatorAux is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real}, (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (forall (E : Set.{u1} α), Continuous.{u1, 0} α ENNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) ENNReal.topologicalSpace (thickenedIndicatorAux.{u1} α _inst_1 δ E))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real}, (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (forall (E : Set.{u1} α), Continuous.{u1, 0} α ENNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) ENNReal.instTopologicalSpaceENNReal (thickenedIndicatorAux.{u1} α _inst_1 δ E))
-Case conversion may be inaccurate. Consider using '#align continuous_thickened_indicator_aux continuous_thickenedIndicatorAuxₓ'. -/
 theorem continuous_thickenedIndicatorAux {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) :
     Continuous (thickenedIndicatorAux δ E) :=
   by
@@ -82,22 +76,10 @@ theorem continuous_thickenedIndicatorAux {δ : ℝ} (δ_pos : 0 < δ) (E : Set 
   norm_num [δ_pos]
 #align continuous_thickened_indicator_aux continuous_thickenedIndicatorAux
 
-/- warning: thickened_indicator_aux_le_one -> thickenedIndicatorAux_le_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] (δ : Real) (E : Set.{u1} α) (x : α), LE.le.{0} ENNReal (Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) (thickenedIndicatorAux.{u1} α _inst_1 δ E x) (OfNat.ofNat.{0} ENNReal 1 (OfNat.mk.{0} ENNReal 1 (One.one.{0} ENNReal (AddMonoidWithOne.toOne.{0} ENNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} ENNReal ENNReal.addCommMonoidWithOne)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] (δ : Real) (E : Set.{u1} α) (x : α), LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (OmegaCompletePartialOrder.toPartialOrder.{0} ENNReal (CompleteLattice.instOmegaCompletePartialOrder.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (thickenedIndicatorAux.{u1} α _inst_1 δ E x) (OfNat.ofNat.{0} ENNReal 1 (One.toOfNat1.{0} ENNReal (CanonicallyOrderedCommSemiring.toOne.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))
-Case conversion may be inaccurate. Consider using '#align thickened_indicator_aux_le_one thickenedIndicatorAux_le_oneₓ'. -/
 theorem thickenedIndicatorAux_le_one (δ : ℝ) (E : Set α) (x : α) :
     thickenedIndicatorAux δ E x ≤ 1 := by apply @tsub_le_self _ _ _ _ (1 : ℝ≥0∞)
 #align thickened_indicator_aux_le_one thickenedIndicatorAux_le_one
 
-/- warning: thickened_indicator_aux_lt_top -> thickenedIndicatorAux_lt_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} {E : Set.{u1} α} {x : α}, LT.lt.{0} ENNReal (Preorder.toHasLt.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) (thickenedIndicatorAux.{u1} α _inst_1 δ E x) (Top.top.{0} ENNReal (CompleteLattice.toHasTop.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} {E : Set.{u1} α} {x : α}, LT.lt.{0} ENNReal (Preorder.toLT.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (OmegaCompletePartialOrder.toPartialOrder.{0} ENNReal (CompleteLattice.instOmegaCompletePartialOrder.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (thickenedIndicatorAux.{u1} α _inst_1 δ E x) (Top.top.{0} ENNReal (CompleteLattice.toTop.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))
-Case conversion may be inaccurate. Consider using '#align thickened_indicator_aux_lt_top thickenedIndicatorAux_lt_topₓ'. -/
 theorem thickenedIndicatorAux_lt_top {δ : ℝ} {E : Set α} {x : α} :
     thickenedIndicatorAux δ E x < ∞ :=
   lt_of_le_of_lt (thickenedIndicatorAux_le_one _ _ _) one_lt_top
@@ -124,12 +106,6 @@ theorem thickenedIndicatorAux_one_of_mem_closure (δ : ℝ) (E : Set α) {x : α
 #align thickened_indicator_aux_one_of_mem_closure thickenedIndicatorAux_one_of_mem_closure
 -/
 
-/- warning: thickened_indicator_aux_zero -> thickenedIndicatorAux_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real}, (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (forall (E : Set.{u1} α) {x : α}, (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.thickening.{u1} α _inst_1 δ E))) -> (Eq.{1} ENNReal (thickenedIndicatorAux.{u1} α _inst_1 δ E x) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real}, (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (forall (E : Set.{u1} α) {x : α}, (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.thickening.{u1} α _inst_1 δ E))) -> (Eq.{1} ENNReal (thickenedIndicatorAux.{u1} α _inst_1 δ E x) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero))))
-Case conversion may be inaccurate. Consider using '#align thickened_indicator_aux_zero thickenedIndicatorAux_zeroₓ'. -/
 theorem thickenedIndicatorAux_zero {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : α}
     (x_out : x ∉ thickening δ E) : thickenedIndicatorAux δ E x = 0 :=
   by
@@ -141,23 +117,11 @@ theorem thickenedIndicatorAux_zero {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x
   simpa using key
 #align thickened_indicator_aux_zero thickenedIndicatorAux_zero
 
-/- warning: thickened_indicator_aux_mono -> thickenedIndicatorAux_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ₁ : Real} {δ₂ : Real}, (LE.le.{0} Real Real.hasLe δ₁ δ₂) -> (forall (E : Set.{u1} α), LE.le.{u1} (α -> ENNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))))) (thickenedIndicatorAux.{u1} α _inst_1 δ₁ E) (thickenedIndicatorAux.{u1} α _inst_1 δ₂ E))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ₁ : Real} {δ₂ : Real}, (LE.le.{0} Real Real.instLEReal δ₁ δ₂) -> (forall (E : Set.{u1} α), LE.le.{u1} (α -> ENNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (OmegaCompletePartialOrder.toPartialOrder.{0} ENNReal (CompleteLattice.instOmegaCompletePartialOrder.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))))) (thickenedIndicatorAux.{u1} α _inst_1 δ₁ E) (thickenedIndicatorAux.{u1} α _inst_1 δ₂ E))
-Case conversion may be inaccurate. Consider using '#align thickened_indicator_aux_mono thickenedIndicatorAux_monoₓ'. -/
 theorem thickenedIndicatorAux_mono {δ₁ δ₂ : ℝ} (hle : δ₁ ≤ δ₂) (E : Set α) :
     thickenedIndicatorAux δ₁ E ≤ thickenedIndicatorAux δ₂ E := fun _ =>
   tsub_le_tsub (@rfl ℝ≥0∞ 1).le (ENNReal.div_le_div rfl.le (ofReal_le_ofReal hle))
 #align thickened_indicator_aux_mono thickenedIndicatorAux_mono
 
-/- warning: indicator_le_thickened_indicator_aux -> indicator_le_thickenedIndicatorAux is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] (δ : Real) (E : Set.{u1} α), LE.le.{u1} (α -> ENNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))))) (Set.indicator.{u1, 0} α ENNReal ENNReal.hasZero E (fun (_x : α) => OfNat.ofNat.{0} ENNReal 1 (OfNat.mk.{0} ENNReal 1 (One.one.{0} ENNReal (AddMonoidWithOne.toOne.{0} ENNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} ENNReal ENNReal.addCommMonoidWithOne)))))) (thickenedIndicatorAux.{u1} α _inst_1 δ E)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] (δ : Real) (E : Set.{u1} α), LE.le.{u1} (α -> ENNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (OmegaCompletePartialOrder.toPartialOrder.{0} ENNReal (CompleteLattice.instOmegaCompletePartialOrder.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))))) (Set.indicator.{u1, 0} α ENNReal instENNRealZero E (fun (_x : α) => OfNat.ofNat.{0} ENNReal 1 (One.toOfNat1.{0} ENNReal (CanonicallyOrderedCommSemiring.toOne.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))) (thickenedIndicatorAux.{u1} α _inst_1 δ E)
-Case conversion may be inaccurate. Consider using '#align indicator_le_thickened_indicator_aux indicator_le_thickenedIndicatorAuxₓ'. -/
 theorem indicator_le_thickenedIndicatorAux (δ : ℝ) (E : Set α) :
     (E.indicator fun _ => (1 : ℝ≥0∞)) ≤ thickenedIndicatorAux δ E :=
   by
@@ -167,23 +131,11 @@ theorem indicator_le_thickenedIndicatorAux (δ : ℝ) (E : Set α) :
   · simp only [h, indicator_of_not_mem, not_false_iff, zero_le]
 #align indicator_le_thickened_indicator_aux indicator_le_thickenedIndicatorAux
 
-/- warning: thickened_indicator_aux_subset -> thickenedIndicatorAux_subset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] (δ : Real) {E₁ : Set.{u1} α} {E₂ : Set.{u1} α}, (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) E₁ E₂) -> (LE.le.{u1} (α -> ENNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))))) (thickenedIndicatorAux.{u1} α _inst_1 δ E₁) (thickenedIndicatorAux.{u1} α _inst_1 δ E₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] (δ : Real) {E₁ : Set.{u1} α} {E₂ : Set.{u1} α}, (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) E₁ E₂) -> (LE.le.{u1} (α -> ENNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (OmegaCompletePartialOrder.toPartialOrder.{0} ENNReal (CompleteLattice.instOmegaCompletePartialOrder.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))))) (thickenedIndicatorAux.{u1} α _inst_1 δ E₁) (thickenedIndicatorAux.{u1} α _inst_1 δ E₂))
-Case conversion may be inaccurate. Consider using '#align thickened_indicator_aux_subset thickenedIndicatorAux_subsetₓ'. -/
 theorem thickenedIndicatorAux_subset (δ : ℝ) {E₁ E₂ : Set α} (subset : E₁ ⊆ E₂) :
     thickenedIndicatorAux δ E₁ ≤ thickenedIndicatorAux δ E₂ := fun _ =>
   tsub_le_tsub (@rfl ℝ≥0∞ 1).le (ENNReal.div_le_div (infEdist_anti subset) rfl.le)
 #align thickened_indicator_aux_subset thickenedIndicatorAux_subset
 
-/- warning: thickened_indicator_aux_tendsto_indicator_closure -> thickenedIndicatorAux_tendsto_indicator_closure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δseq : Nat -> Real}, (Filter.Tendsto.{0, 0} Nat Real δseq (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) -> (forall (E : Set.{u1} α), Filter.Tendsto.{0, u1} Nat (α -> ENNReal) (fun (n : Nat) => thickenedIndicatorAux.{u1} α _inst_1 (δseq n) E) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} (α -> ENNReal) (Pi.topologicalSpace.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (a : α) => ENNReal.topologicalSpace)) (Set.indicator.{u1, 0} α ENNReal ENNReal.hasZero (closure.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) E) (fun (x : α) => OfNat.ofNat.{0} ENNReal 1 (OfNat.mk.{0} ENNReal 1 (One.one.{0} ENNReal (AddMonoidWithOne.toOne.{0} ENNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} ENNReal ENNReal.addCommMonoidWithOne))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δseq : Nat -> Real}, (Filter.Tendsto.{0, 0} Nat Real δseq (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) -> (forall (E : Set.{u1} α), Filter.Tendsto.{0, u1} Nat (α -> ENNReal) (fun (n : Nat) => thickenedIndicatorAux.{u1} α _inst_1 (δseq n) E) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} (α -> ENNReal) (Pi.topologicalSpace.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (a : α) => ENNReal.instTopologicalSpaceENNReal)) (Set.indicator.{u1, 0} α ENNReal instENNRealZero (closure.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) E) (fun (x : α) => OfNat.ofNat.{0} ENNReal 1 (One.toOfNat1.{0} ENNReal (CanonicallyOrderedCommSemiring.toOne.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))))))
-Case conversion may be inaccurate. Consider using '#align thickened_indicator_aux_tendsto_indicator_closure thickenedIndicatorAux_tendsto_indicator_closureₓ'. -/
 /-- As the thickening radius δ tends to 0, the δ-thickened indicator of a set E (in α) tends
 pointwise (i.e., w.r.t. the product topology on `α → ℝ≥0∞`) to the indicator function of the
 closure of E.
@@ -218,12 +170,6 @@ theorem thickenedIndicatorAux_tendsto_indicator_closure {δseq : ℕ → ℝ}
     exact (thickenedIndicatorAux_zero ε_pos E key).le
 #align thickened_indicator_aux_tendsto_indicator_closure thickenedIndicatorAux_tendsto_indicator_closure
 
-/- warning: thickened_indicator -> thickenedIndicator is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real}, (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (Set.{u1} α) -> (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real}, (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (Set.{u1} α) -> (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal)
-Case conversion may be inaccurate. Consider using '#align thickened_indicator thickenedIndicatorₓ'. -/
 /-- The `δ`-thickened indicator of a set `E` is the function that equals `1` on `E`
 and `0` outside a `δ`-thickening of `E` and interpolates (continuously) between
 these values using `inf_edist _ E`.
@@ -254,23 +200,11 @@ def thickenedIndicator {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) : α →ᵇ ℝ
           (to_nnreal_le_to_nnreal (lt_of_le_of_lt (key _) one_lt_top).Ne one_ne_top).mpr (key _)
 #align thickened_indicator thickenedIndicator
 
-/- warning: thickened_indicator.coe_fn_eq_comp -> thickenedIndicator.coeFn_eq_comp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) (E : Set.{u1} α), Eq.{succ u1} (α -> NNReal) (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E)) (Function.comp.{succ u1, 1, 1} α ENNReal NNReal ENNReal.toNNReal (thickenedIndicatorAux.{u1} α _inst_1 δ E))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) (E : Set.{u1} α), Eq.{succ u1} (forall (ᾰ : α), (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E)) (Function.comp.{succ u1, 1, 1} α ENNReal NNReal ENNReal.toNNReal (thickenedIndicatorAux.{u1} α _inst_1 δ E))
-Case conversion may be inaccurate. Consider using '#align thickened_indicator.coe_fn_eq_comp thickenedIndicator.coeFn_eq_compₓ'. -/
 theorem thickenedIndicator.coeFn_eq_comp {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) :
     ⇑(thickenedIndicator δ_pos E) = ENNReal.toNNReal ∘ thickenedIndicatorAux δ E :=
   rfl
 #align thickened_indicator.coe_fn_eq_comp thickenedIndicator.coeFn_eq_comp
 
-/- warning: thickened_indicator_le_one -> thickenedIndicator_le_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) (E : Set.{u1} α) (x : α), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E) x) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) (E : Set.{u1} α) (x : α), LE.le.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) (Preorder.toLE.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) (PartialOrder.toPreorder.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) (StrictOrderedSemiring.toPartialOrder.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) instNNRealStrictOrderedSemiring))) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E) x) (OfNat.ofNat.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) 1 (One.toOfNat1.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) instNNRealOne))
-Case conversion may be inaccurate. Consider using '#align thickened_indicator_le_one thickenedIndicator_le_oneₓ'. -/
 theorem thickenedIndicator_le_one {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) (x : α) :
     thickenedIndicator δ_pos E x ≤ 1 :=
   by
@@ -280,45 +214,21 @@ theorem thickenedIndicator_le_one {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) (x :
       (thickenedIndicatorAux_le_one δ E x)
 #align thickened_indicator_le_one thickenedIndicator_le_one
 
-/- warning: thickened_indicator_one_of_mem_closure -> thickenedIndicator_one_of_mem_closure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) (E : Set.{u1} α) {x : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (closure.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) E)) -> (Eq.{1} NNReal (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E) x) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) (E : Set.{u1} α) {x : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (closure.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) E)) -> (Eq.{1} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E) x) (OfNat.ofNat.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) 1 (One.toOfNat1.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) instNNRealOne)))
-Case conversion may be inaccurate. Consider using '#align thickened_indicator_one_of_mem_closure thickenedIndicator_one_of_mem_closureₓ'. -/
 theorem thickenedIndicator_one_of_mem_closure {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : α}
     (x_mem : x ∈ closure E) : thickenedIndicator δ_pos E x = 1 := by
   rw [thickenedIndicator_apply, thickenedIndicatorAux_one_of_mem_closure δ E x_mem, one_to_nnreal]
 #align thickened_indicator_one_of_mem_closure thickenedIndicator_one_of_mem_closure
 
-/- warning: thickened_indicator_one -> thickenedIndicator_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) (E : Set.{u1} α) {x : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x E) -> (Eq.{1} NNReal (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E) x) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) (E : Set.{u1} α) {x : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x E) -> (Eq.{1} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E) x) (OfNat.ofNat.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) 1 (One.toOfNat1.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) instNNRealOne)))
-Case conversion may be inaccurate. Consider using '#align thickened_indicator_one thickenedIndicator_oneₓ'. -/
 theorem thickenedIndicator_one {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : α} (x_in_E : x ∈ E) :
     thickenedIndicator δ_pos E x = 1 :=
   thickenedIndicator_one_of_mem_closure _ _ (subset_closure x_in_E)
 #align thickened_indicator_one thickenedIndicator_one
 
-/- warning: thickened_indicator_zero -> thickenedIndicator_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) (E : Set.{u1} α) {x : α}, (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.thickening.{u1} α _inst_1 δ E))) -> (Eq.{1} NNReal (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E) x) (OfNat.ofNat.{0} NNReal 0 (OfNat.mk.{0} NNReal 0 (Zero.zero.{0} NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) (E : Set.{u1} α) {x : α}, (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.thickening.{u1} α _inst_1 δ E))) -> (Eq.{1} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E) x) (OfNat.ofNat.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) 0 (Zero.toOfNat0.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) instNNRealZero)))
-Case conversion may be inaccurate. Consider using '#align thickened_indicator_zero thickenedIndicator_zeroₓ'. -/
 theorem thickenedIndicator_zero {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : α}
     (x_out : x ∉ thickening δ E) : thickenedIndicator δ_pos E x = 0 := by
   rw [thickenedIndicator_apply, thickenedIndicatorAux_zero δ_pos E x_out, zero_to_nnreal]
 #align thickened_indicator_zero thickenedIndicator_zero
 
-/- warning: indicator_le_thickened_indicator -> indicator_le_thickenedIndicator is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) (E : Set.{u1} α), LE.le.{u1} (α -> NNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => NNReal) (fun (i : α) => Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring))))) (Set.indicator.{u1, 0} α NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))) E (fun (_x : α) => OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))))))) (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) (E : Set.{u1} α), LE.le.{u1} (α -> NNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => NNReal) (fun (i : α) => Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring)))) (Set.indicator.{u1, 0} α NNReal instNNRealZero E (fun (_x : α) => OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne))) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E))
-Case conversion may be inaccurate. Consider using '#align indicator_le_thickened_indicator indicator_le_thickenedIndicatorₓ'. -/
 theorem indicator_le_thickenedIndicator {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) :
     (E.indicator fun _ => (1 : ℝ≥0)) ≤ thickenedIndicator δ_pos E :=
   by
@@ -328,12 +238,6 @@ theorem indicator_le_thickenedIndicator {δ : ℝ} (δ_pos : 0 < δ) (E : Set α
   · simp only [h, indicator_of_not_mem, not_false_iff, zero_le]
 #align indicator_le_thickened_indicator indicator_le_thickenedIndicator
 
-/- warning: thickened_indicator_mono -> thickenedIndicator_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ₁ : Real} {δ₂ : Real} (δ₁_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ₁) (δ₂_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ₂), (LE.le.{0} Real Real.hasLe δ₁ δ₂) -> (forall (E : Set.{u1} α), LE.le.{u1} (α -> NNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => NNReal) (fun (i : α) => Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring))))) (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ₁ δ₁_pos E)) (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ₂ δ₂_pos E)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ₁ : Real} {δ₂ : Real} (δ₁_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ₁) (δ₂_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ₂), (LE.le.{0} Real Real.instLEReal δ₁ δ₂) -> (forall (E : Set.{u1} α), LE.le.{u1} (forall (ᾰ : α), (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (fun (i : α) => Preorder.toLE.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) i) (PartialOrder.toPreorder.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) i) (StrictOrderedSemiring.toPartialOrder.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) i) instNNRealStrictOrderedSemiring)))) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ₁ δ₁_pos E)) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ₂ δ₂_pos E)))
-Case conversion may be inaccurate. Consider using '#align thickened_indicator_mono thickenedIndicator_monoₓ'. -/
 theorem thickenedIndicator_mono {δ₁ δ₂ : ℝ} (δ₁_pos : 0 < δ₁) (δ₂_pos : 0 < δ₂) (hle : δ₁ ≤ δ₂)
     (E : Set α) : ⇑(thickenedIndicator δ₁_pos E) ≤ thickenedIndicator δ₂_pos E :=
   by
@@ -343,24 +247,12 @@ theorem thickenedIndicator_mono {δ₁ δ₂ : ℝ} (δ₁_pos : 0 < δ₁) (δ
   apply thickenedIndicatorAux_mono hle
 #align thickened_indicator_mono thickenedIndicator_mono
 
-/- warning: thickened_indicator_subset -> thickenedIndicator_subset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) {E₁ : Set.{u1} α} {E₂ : Set.{u1} α}, (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) E₁ E₂) -> (LE.le.{u1} (α -> NNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => NNReal) (fun (i : α) => Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring))))) (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E₁)) (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E₂)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) {E₁ : Set.{u1} α} {E₂ : Set.{u1} α}, (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) E₁ E₂) -> (LE.le.{u1} (forall (ᾰ : α), (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (fun (i : α) => Preorder.toLE.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) i) (PartialOrder.toPreorder.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) i) (StrictOrderedSemiring.toPartialOrder.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) i) instNNRealStrictOrderedSemiring)))) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E₁)) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E₂)))
-Case conversion may be inaccurate. Consider using '#align thickened_indicator_subset thickenedIndicator_subsetₓ'. -/
 theorem thickenedIndicator_subset {δ : ℝ} (δ_pos : 0 < δ) {E₁ E₂ : Set α} (subset : E₁ ⊆ E₂) :
     ⇑(thickenedIndicator δ_pos E₁) ≤ thickenedIndicator δ_pos E₂ := fun x =>
   (toNNReal_le_toNNReal thickenedIndicatorAux_lt_top.Ne thickenedIndicatorAux_lt_top.Ne).mpr
     (thickenedIndicatorAux_subset δ subset x)
 #align thickened_indicator_subset thickenedIndicator_subset
 
-/- warning: thickened_indicator_tendsto_indicator_closure -> thickenedIndicator_tendsto_indicator_closure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δseq : Nat -> Real} (δseq_pos : forall (n : Nat), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (δseq n)), (Filter.Tendsto.{0, 0} Nat Real δseq (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) -> (forall (E : Set.{u1} α), Filter.Tendsto.{0, u1} Nat (α -> NNReal) (fun (n : Nat) => coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (ᾰ : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 (δseq n) (δseq_pos n) E)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} (α -> NNReal) (Pi.topologicalSpace.{u1, 0} α (fun (ᾰ : α) => NNReal) (fun (a : α) => NNReal.topologicalSpace)) (Set.indicator.{u1, 0} α NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))) (closure.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) E) (fun (x : α) => OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δseq : Nat -> Real} (δseq_pos : forall (n : Nat), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (δseq n)), (Filter.Tendsto.{0, 0} Nat Real δseq (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) -> (forall (E : Set.{u1} α), Filter.Tendsto.{0, u1} Nat (forall (ᾰ : α), (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (fun (n : Nat) => FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (ᾰ : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 (δseq n) (δseq_pos n) E)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} (forall (ᾰ : α), (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (Pi.topologicalSpace.{u1, 0} α (fun (ᾰ : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (fun (a : α) => NNReal.instTopologicalSpaceNNReal)) (Set.indicator.{u1, 0} α NNReal instNNRealZero (closure.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) E) (fun (x : α) => OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)))))
-Case conversion may be inaccurate. Consider using '#align thickened_indicator_tendsto_indicator_closure thickenedIndicator_tendsto_indicator_closureₓ'. -/
 /-- As the thickening radius δ tends to 0, the δ-thickened indicator of a set E (in α) tends
 pointwise to the indicator function of the closure of E.
 

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kalle Kytölä
 
 ! This file was ported from Lean 3 source module topology.metric_space.thickened_indicator
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
+! leanprover-community/mathlib commit 38df578a6450a8c5142b3727e3ae894c2300cae0
 ! 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.MetricSpace.HausdorffDistance
 /-!
 # Thickened indicators
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 This file is about thickened indicators of sets in (pseudo e)metric spaces. For a decreasing
 sequence of thickening radii tending to 0, the thickened indicators of a closed set form a
 decreasing pointwise converging approximation of the indicator function of the set, where the

mathlib commit https://github.com/leanprover-community/mathlib/commit/75e7fca56381d056096ce5d05e938f63a6567828

@@ -49,6 +49,7 @@ section thickenedIndicator
 
 variable {α : Type _} [PseudoEMetricSpace α]
 
+#print thickenedIndicatorAux /-
 /-- The `δ`-thickened indicator of a set `E` is the function that equals `1` on `E`
 and `0` outside a `δ`-thickening of `E` and interpolates (continuously) between
 these values using `inf_edist _ E`.
@@ -58,7 +59,14 @@ for the (bundled) bounded continuous function with `ℝ≥0`-values. -/
 def thickenedIndicatorAux (δ : ℝ) (E : Set α) : α → ℝ≥0∞ := fun x : α =>
   (1 : ℝ≥0∞) - infEdist x E / ENNReal.ofReal δ
 #align thickened_indicator_aux thickenedIndicatorAux
+-/
 
+/- warning: continuous_thickened_indicator_aux -> continuous_thickenedIndicatorAux is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real}, (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (forall (E : Set.{u1} α), Continuous.{u1, 0} α ENNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) ENNReal.topologicalSpace (thickenedIndicatorAux.{u1} α _inst_1 δ E))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real}, (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (forall (E : Set.{u1} α), Continuous.{u1, 0} α ENNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) ENNReal.instTopologicalSpaceENNReal (thickenedIndicatorAux.{u1} α _inst_1 δ E))
+Case conversion may be inaccurate. Consider using '#align continuous_thickened_indicator_aux continuous_thickenedIndicatorAuxₓ'. -/
 theorem continuous_thickenedIndicatorAux {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) :
     Continuous (thickenedIndicatorAux δ E) :=
   by
@@ -71,30 +79,54 @@ theorem continuous_thickenedIndicatorAux {δ : ℝ} (δ_pos : 0 < δ) (E : Set 
   norm_num [δ_pos]
 #align continuous_thickened_indicator_aux continuous_thickenedIndicatorAux
 
+/- warning: thickened_indicator_aux_le_one -> thickenedIndicatorAux_le_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] (δ : Real) (E : Set.{u1} α) (x : α), LE.le.{0} ENNReal (Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) (thickenedIndicatorAux.{u1} α _inst_1 δ E x) (OfNat.ofNat.{0} ENNReal 1 (OfNat.mk.{0} ENNReal 1 (One.one.{0} ENNReal (AddMonoidWithOne.toOne.{0} ENNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} ENNReal ENNReal.addCommMonoidWithOne)))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] (δ : Real) (E : Set.{u1} α) (x : α), LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (OmegaCompletePartialOrder.toPartialOrder.{0} ENNReal (CompleteLattice.instOmegaCompletePartialOrder.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (thickenedIndicatorAux.{u1} α _inst_1 δ E x) (OfNat.ofNat.{0} ENNReal 1 (One.toOfNat1.{0} ENNReal (CanonicallyOrderedCommSemiring.toOne.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))
+Case conversion may be inaccurate. Consider using '#align thickened_indicator_aux_le_one thickenedIndicatorAux_le_oneₓ'. -/
 theorem thickenedIndicatorAux_le_one (δ : ℝ) (E : Set α) (x : α) :
     thickenedIndicatorAux δ E x ≤ 1 := by apply @tsub_le_self _ _ _ _ (1 : ℝ≥0∞)
 #align thickened_indicator_aux_le_one thickenedIndicatorAux_le_one
 
+/- warning: thickened_indicator_aux_lt_top -> thickenedIndicatorAux_lt_top is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} {E : Set.{u1} α} {x : α}, LT.lt.{0} ENNReal (Preorder.toHasLt.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) (thickenedIndicatorAux.{u1} α _inst_1 δ E x) (Top.top.{0} ENNReal (CompleteLattice.toHasTop.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} {E : Set.{u1} α} {x : α}, LT.lt.{0} ENNReal (Preorder.toLT.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (OmegaCompletePartialOrder.toPartialOrder.{0} ENNReal (CompleteLattice.instOmegaCompletePartialOrder.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (thickenedIndicatorAux.{u1} α _inst_1 δ E x) (Top.top.{0} ENNReal (CompleteLattice.toTop.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))
+Case conversion may be inaccurate. Consider using '#align thickened_indicator_aux_lt_top thickenedIndicatorAux_lt_topₓ'. -/
 theorem thickenedIndicatorAux_lt_top {δ : ℝ} {E : Set α} {x : α} :
     thickenedIndicatorAux δ E x < ∞ :=
   lt_of_le_of_lt (thickenedIndicatorAux_le_one _ _ _) one_lt_top
 #align thickened_indicator_aux_lt_top thickenedIndicatorAux_lt_top
 
+#print thickenedIndicatorAux_closure_eq /-
 theorem thickenedIndicatorAux_closure_eq (δ : ℝ) (E : Set α) :
     thickenedIndicatorAux δ (closure E) = thickenedIndicatorAux δ E := by
   simp_rw [thickenedIndicatorAux, inf_edist_closure]
 #align thickened_indicator_aux_closure_eq thickenedIndicatorAux_closure_eq
+-/
 
+#print thickenedIndicatorAux_one /-
 theorem thickenedIndicatorAux_one (δ : ℝ) (E : Set α) {x : α} (x_in_E : x ∈ E) :
     thickenedIndicatorAux δ E x = 1 := by
   simp [thickenedIndicatorAux, inf_edist_zero_of_mem x_in_E, tsub_zero]
 #align thickened_indicator_aux_one thickenedIndicatorAux_one
+-/
 
+#print thickenedIndicatorAux_one_of_mem_closure /-
 theorem thickenedIndicatorAux_one_of_mem_closure (δ : ℝ) (E : Set α) {x : α}
     (x_mem : x ∈ closure E) : thickenedIndicatorAux δ E x = 1 := by
   rw [← thickenedIndicatorAux_closure_eq, thickenedIndicatorAux_one δ (closure E) x_mem]
 #align thickened_indicator_aux_one_of_mem_closure thickenedIndicatorAux_one_of_mem_closure
+-/
 
+/- warning: thickened_indicator_aux_zero -> thickenedIndicatorAux_zero is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real}, (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (forall (E : Set.{u1} α) {x : α}, (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.thickening.{u1} α _inst_1 δ E))) -> (Eq.{1} ENNReal (thickenedIndicatorAux.{u1} α _inst_1 δ E x) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero)))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real}, (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (forall (E : Set.{u1} α) {x : α}, (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.thickening.{u1} α _inst_1 δ E))) -> (Eq.{1} ENNReal (thickenedIndicatorAux.{u1} α _inst_1 δ E x) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero))))
+Case conversion may be inaccurate. Consider using '#align thickened_indicator_aux_zero thickenedIndicatorAux_zeroₓ'. -/
 theorem thickenedIndicatorAux_zero {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : α}
     (x_out : x ∉ thickening δ E) : thickenedIndicatorAux δ E x = 0 :=
   by
@@ -106,11 +138,23 @@ theorem thickenedIndicatorAux_zero {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x
   simpa using key
 #align thickened_indicator_aux_zero thickenedIndicatorAux_zero
 
+/- warning: thickened_indicator_aux_mono -> thickenedIndicatorAux_mono is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ₁ : Real} {δ₂ : Real}, (LE.le.{0} Real Real.hasLe δ₁ δ₂) -> (forall (E : Set.{u1} α), LE.le.{u1} (α -> ENNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))))) (thickenedIndicatorAux.{u1} α _inst_1 δ₁ E) (thickenedIndicatorAux.{u1} α _inst_1 δ₂ E))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ₁ : Real} {δ₂ : Real}, (LE.le.{0} Real Real.instLEReal δ₁ δ₂) -> (forall (E : Set.{u1} α), LE.le.{u1} (α -> ENNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (OmegaCompletePartialOrder.toPartialOrder.{0} ENNReal (CompleteLattice.instOmegaCompletePartialOrder.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))))) (thickenedIndicatorAux.{u1} α _inst_1 δ₁ E) (thickenedIndicatorAux.{u1} α _inst_1 δ₂ E))
+Case conversion may be inaccurate. Consider using '#align thickened_indicator_aux_mono thickenedIndicatorAux_monoₓ'. -/
 theorem thickenedIndicatorAux_mono {δ₁ δ₂ : ℝ} (hle : δ₁ ≤ δ₂) (E : Set α) :
     thickenedIndicatorAux δ₁ E ≤ thickenedIndicatorAux δ₂ E := fun _ =>
   tsub_le_tsub (@rfl ℝ≥0∞ 1).le (ENNReal.div_le_div rfl.le (ofReal_le_ofReal hle))
 #align thickened_indicator_aux_mono thickenedIndicatorAux_mono
 
+/- warning: indicator_le_thickened_indicator_aux -> indicator_le_thickenedIndicatorAux is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] (δ : Real) (E : Set.{u1} α), LE.le.{u1} (α -> ENNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))))) (Set.indicator.{u1, 0} α ENNReal ENNReal.hasZero E (fun (_x : α) => OfNat.ofNat.{0} ENNReal 1 (OfNat.mk.{0} ENNReal 1 (One.one.{0} ENNReal (AddMonoidWithOne.toOne.{0} ENNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} ENNReal ENNReal.addCommMonoidWithOne)))))) (thickenedIndicatorAux.{u1} α _inst_1 δ E)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] (δ : Real) (E : Set.{u1} α), LE.le.{u1} (α -> ENNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (OmegaCompletePartialOrder.toPartialOrder.{0} ENNReal (CompleteLattice.instOmegaCompletePartialOrder.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))))) (Set.indicator.{u1, 0} α ENNReal instENNRealZero E (fun (_x : α) => OfNat.ofNat.{0} ENNReal 1 (One.toOfNat1.{0} ENNReal (CanonicallyOrderedCommSemiring.toOne.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))) (thickenedIndicatorAux.{u1} α _inst_1 δ E)
+Case conversion may be inaccurate. Consider using '#align indicator_le_thickened_indicator_aux indicator_le_thickenedIndicatorAuxₓ'. -/
 theorem indicator_le_thickenedIndicatorAux (δ : ℝ) (E : Set α) :
     (E.indicator fun _ => (1 : ℝ≥0∞)) ≤ thickenedIndicatorAux δ E :=
   by
@@ -120,11 +164,23 @@ theorem indicator_le_thickenedIndicatorAux (δ : ℝ) (E : Set α) :
   · simp only [h, indicator_of_not_mem, not_false_iff, zero_le]
 #align indicator_le_thickened_indicator_aux indicator_le_thickenedIndicatorAux
 
+/- warning: thickened_indicator_aux_subset -> thickenedIndicatorAux_subset is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] (δ : Real) {E₁ : Set.{u1} α} {E₂ : Set.{u1} α}, (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) E₁ E₂) -> (LE.le.{u1} (α -> ENNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))))) (thickenedIndicatorAux.{u1} α _inst_1 δ E₁) (thickenedIndicatorAux.{u1} α _inst_1 δ E₂))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] (δ : Real) {E₁ : Set.{u1} α} {E₂ : Set.{u1} α}, (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) E₁ E₂) -> (LE.le.{u1} (α -> ENNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (OmegaCompletePartialOrder.toPartialOrder.{0} ENNReal (CompleteLattice.instOmegaCompletePartialOrder.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))))) (thickenedIndicatorAux.{u1} α _inst_1 δ E₁) (thickenedIndicatorAux.{u1} α _inst_1 δ E₂))
+Case conversion may be inaccurate. Consider using '#align thickened_indicator_aux_subset thickenedIndicatorAux_subsetₓ'. -/
 theorem thickenedIndicatorAux_subset (δ : ℝ) {E₁ E₂ : Set α} (subset : E₁ ⊆ E₂) :
     thickenedIndicatorAux δ E₁ ≤ thickenedIndicatorAux δ E₂ := fun _ =>
   tsub_le_tsub (@rfl ℝ≥0∞ 1).le (ENNReal.div_le_div (infEdist_anti subset) rfl.le)
 #align thickened_indicator_aux_subset thickenedIndicatorAux_subset
 
+/- warning: thickened_indicator_aux_tendsto_indicator_closure -> thickenedIndicatorAux_tendsto_indicator_closure is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δseq : Nat -> Real}, (Filter.Tendsto.{0, 0} Nat Real δseq (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) -> (forall (E : Set.{u1} α), Filter.Tendsto.{0, u1} Nat (α -> ENNReal) (fun (n : Nat) => thickenedIndicatorAux.{u1} α _inst_1 (δseq n) E) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} (α -> ENNReal) (Pi.topologicalSpace.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (a : α) => ENNReal.topologicalSpace)) (Set.indicator.{u1, 0} α ENNReal ENNReal.hasZero (closure.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) E) (fun (x : α) => OfNat.ofNat.{0} ENNReal 1 (OfNat.mk.{0} ENNReal 1 (One.one.{0} ENNReal (AddMonoidWithOne.toOne.{0} ENNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} ENNReal ENNReal.addCommMonoidWithOne))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δseq : Nat -> Real}, (Filter.Tendsto.{0, 0} Nat Real δseq (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) -> (forall (E : Set.{u1} α), Filter.Tendsto.{0, u1} Nat (α -> ENNReal) (fun (n : Nat) => thickenedIndicatorAux.{u1} α _inst_1 (δseq n) E) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} (α -> ENNReal) (Pi.topologicalSpace.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (a : α) => ENNReal.instTopologicalSpaceENNReal)) (Set.indicator.{u1, 0} α ENNReal instENNRealZero (closure.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) E) (fun (x : α) => OfNat.ofNat.{0} ENNReal 1 (One.toOfNat1.{0} ENNReal (CanonicallyOrderedCommSemiring.toOne.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))))))
+Case conversion may be inaccurate. Consider using '#align thickened_indicator_aux_tendsto_indicator_closure thickenedIndicatorAux_tendsto_indicator_closureₓ'. -/
 /-- As the thickening radius δ tends to 0, the δ-thickened indicator of a set E (in α) tends
 pointwise (i.e., w.r.t. the product topology on `α → ℝ≥0∞`) to the indicator function of the
 closure of E.
@@ -159,6 +215,12 @@ theorem thickenedIndicatorAux_tendsto_indicator_closure {δseq : ℕ → ℝ}
     exact (thickenedIndicatorAux_zero ε_pos E key).le
 #align thickened_indicator_aux_tendsto_indicator_closure thickenedIndicatorAux_tendsto_indicator_closure
 
+/- warning: thickened_indicator -> thickenedIndicator is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real}, (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (Set.{u1} α) -> (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real}, (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (Set.{u1} α) -> (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal)
+Case conversion may be inaccurate. Consider using '#align thickened_indicator thickenedIndicatorₓ'. -/
 /-- The `δ`-thickened indicator of a set `E` is the function that equals `1` on `E`
 and `0` outside a `δ`-thickening of `E` and interpolates (continuously) between
 these values using `inf_edist _ E`.
@@ -189,11 +251,23 @@ def thickenedIndicator {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) : α →ᵇ ℝ
           (to_nnreal_le_to_nnreal (lt_of_le_of_lt (key _) one_lt_top).Ne one_ne_top).mpr (key _)
 #align thickened_indicator thickenedIndicator
 
+/- warning: thickened_indicator.coe_fn_eq_comp -> thickenedIndicator.coeFn_eq_comp is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) (E : Set.{u1} α), Eq.{succ u1} (α -> NNReal) (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E)) (Function.comp.{succ u1, 1, 1} α ENNReal NNReal ENNReal.toNNReal (thickenedIndicatorAux.{u1} α _inst_1 δ E))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) (E : Set.{u1} α), Eq.{succ u1} (forall (ᾰ : α), (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E)) (Function.comp.{succ u1, 1, 1} α ENNReal NNReal ENNReal.toNNReal (thickenedIndicatorAux.{u1} α _inst_1 δ E))
+Case conversion may be inaccurate. Consider using '#align thickened_indicator.coe_fn_eq_comp thickenedIndicator.coeFn_eq_compₓ'. -/
 theorem thickenedIndicator.coeFn_eq_comp {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) :
     ⇑(thickenedIndicator δ_pos E) = ENNReal.toNNReal ∘ thickenedIndicatorAux δ E :=
   rfl
 #align thickened_indicator.coe_fn_eq_comp thickenedIndicator.coeFn_eq_comp
 
+/- warning: thickened_indicator_le_one -> thickenedIndicator_le_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) (E : Set.{u1} α) (x : α), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E) x) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) (E : Set.{u1} α) (x : α), LE.le.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) (Preorder.toLE.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) (PartialOrder.toPreorder.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) (StrictOrderedSemiring.toPartialOrder.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) instNNRealStrictOrderedSemiring))) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E) x) (OfNat.ofNat.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) 1 (One.toOfNat1.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) instNNRealOne))
+Case conversion may be inaccurate. Consider using '#align thickened_indicator_le_one thickenedIndicator_le_oneₓ'. -/
 theorem thickenedIndicator_le_one {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) (x : α) :
     thickenedIndicator δ_pos E x ≤ 1 :=
   by
@@ -203,21 +277,45 @@ theorem thickenedIndicator_le_one {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) (x :
       (thickenedIndicatorAux_le_one δ E x)
 #align thickened_indicator_le_one thickenedIndicator_le_one
 
+/- warning: thickened_indicator_one_of_mem_closure -> thickenedIndicator_one_of_mem_closure is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) (E : Set.{u1} α) {x : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (closure.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) E)) -> (Eq.{1} NNReal (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E) x) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) (E : Set.{u1} α) {x : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (closure.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) E)) -> (Eq.{1} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E) x) (OfNat.ofNat.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) 1 (One.toOfNat1.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) instNNRealOne)))
+Case conversion may be inaccurate. Consider using '#align thickened_indicator_one_of_mem_closure thickenedIndicator_one_of_mem_closureₓ'. -/
 theorem thickenedIndicator_one_of_mem_closure {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : α}
     (x_mem : x ∈ closure E) : thickenedIndicator δ_pos E x = 1 := by
   rw [thickenedIndicator_apply, thickenedIndicatorAux_one_of_mem_closure δ E x_mem, one_to_nnreal]
 #align thickened_indicator_one_of_mem_closure thickenedIndicator_one_of_mem_closure
 
+/- warning: thickened_indicator_one -> thickenedIndicator_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) (E : Set.{u1} α) {x : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x E) -> (Eq.{1} NNReal (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E) x) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) (E : Set.{u1} α) {x : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x E) -> (Eq.{1} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E) x) (OfNat.ofNat.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) 1 (One.toOfNat1.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) instNNRealOne)))
+Case conversion may be inaccurate. Consider using '#align thickened_indicator_one thickenedIndicator_oneₓ'. -/
 theorem thickenedIndicator_one {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : α} (x_in_E : x ∈ E) :
     thickenedIndicator δ_pos E x = 1 :=
   thickenedIndicator_one_of_mem_closure _ _ (subset_closure x_in_E)
 #align thickened_indicator_one thickenedIndicator_one
 
+/- warning: thickened_indicator_zero -> thickenedIndicator_zero is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) (E : Set.{u1} α) {x : α}, (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Metric.thickening.{u1} α _inst_1 δ E))) -> (Eq.{1} NNReal (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E) x) (OfNat.ofNat.{0} NNReal 0 (OfNat.mk.{0} NNReal 0 (Zero.zero.{0} NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) (E : Set.{u1} α) {x : α}, (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Metric.thickening.{u1} α _inst_1 δ E))) -> (Eq.{1} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E) x) (OfNat.ofNat.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) 0 (Zero.toOfNat0.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) x) instNNRealZero)))
+Case conversion may be inaccurate. Consider using '#align thickened_indicator_zero thickenedIndicator_zeroₓ'. -/
 theorem thickenedIndicator_zero {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : α}
     (x_out : x ∉ thickening δ E) : thickenedIndicator δ_pos E x = 0 := by
   rw [thickenedIndicator_apply, thickenedIndicatorAux_zero δ_pos E x_out, zero_to_nnreal]
 #align thickened_indicator_zero thickenedIndicator_zero
 
+/- warning: indicator_le_thickened_indicator -> indicator_le_thickenedIndicator is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) (E : Set.{u1} α), LE.le.{u1} (α -> NNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => NNReal) (fun (i : α) => Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring))))) (Set.indicator.{u1, 0} α NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))) E (fun (_x : α) => OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))))))) (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) (E : Set.{u1} α), LE.le.{u1} (α -> NNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => NNReal) (fun (i : α) => Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring)))) (Set.indicator.{u1, 0} α NNReal instNNRealZero E (fun (_x : α) => OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne))) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E))
+Case conversion may be inaccurate. Consider using '#align indicator_le_thickened_indicator indicator_le_thickenedIndicatorₓ'. -/
 theorem indicator_le_thickenedIndicator {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) :
     (E.indicator fun _ => (1 : ℝ≥0)) ≤ thickenedIndicator δ_pos E :=
   by
@@ -227,6 +325,12 @@ theorem indicator_le_thickenedIndicator {δ : ℝ} (δ_pos : 0 < δ) (E : Set α
   · simp only [h, indicator_of_not_mem, not_false_iff, zero_le]
 #align indicator_le_thickened_indicator indicator_le_thickenedIndicator
 
+/- warning: thickened_indicator_mono -> thickenedIndicator_mono is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ₁ : Real} {δ₂ : Real} (δ₁_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ₁) (δ₂_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ₂), (LE.le.{0} Real Real.hasLe δ₁ δ₂) -> (forall (E : Set.{u1} α), LE.le.{u1} (α -> NNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => NNReal) (fun (i : α) => Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring))))) (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ₁ δ₁_pos E)) (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ₂ δ₂_pos E)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ₁ : Real} {δ₂ : Real} (δ₁_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ₁) (δ₂_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ₂), (LE.le.{0} Real Real.instLEReal δ₁ δ₂) -> (forall (E : Set.{u1} α), LE.le.{u1} (forall (ᾰ : α), (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (fun (i : α) => Preorder.toLE.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) i) (PartialOrder.toPreorder.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) i) (StrictOrderedSemiring.toPartialOrder.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) i) instNNRealStrictOrderedSemiring)))) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ₁ δ₁_pos E)) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ₂ δ₂_pos E)))
+Case conversion may be inaccurate. Consider using '#align thickened_indicator_mono thickenedIndicator_monoₓ'. -/
 theorem thickenedIndicator_mono {δ₁ δ₂ : ℝ} (δ₁_pos : 0 < δ₁) (δ₂_pos : 0 < δ₂) (hle : δ₁ ≤ δ₂)
     (E : Set α) : ⇑(thickenedIndicator δ₁_pos E) ≤ thickenedIndicator δ₂_pos E :=
   by
@@ -236,12 +340,24 @@ theorem thickenedIndicator_mono {δ₁ δ₂ : ℝ} (δ₁_pos : 0 < δ₁) (δ
   apply thickenedIndicatorAux_mono hle
 #align thickened_indicator_mono thickenedIndicator_mono
 
+/- warning: thickened_indicator_subset -> thickenedIndicator_subset is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) {E₁ : Set.{u1} α} {E₂ : Set.{u1} α}, (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) E₁ E₂) -> (LE.le.{u1} (α -> NNReal) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => NNReal) (fun (i : α) => Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring))))) (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E₁)) (coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (_x : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E₂)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δ : Real} (δ_pos : LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) {E₁ : Set.{u1} α} {E₂ : Set.{u1} α}, (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) E₁ E₂) -> (LE.le.{u1} (forall (ᾰ : α), (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (Pi.hasLe.{u1, 0} α (fun (ᾰ : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (fun (i : α) => Preorder.toLE.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) i) (PartialOrder.toPreorder.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) i) (StrictOrderedSemiring.toPartialOrder.{0} ((fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) i) instNNRealStrictOrderedSemiring)))) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E₁)) (FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (_x : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) _x) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 δ δ_pos E₂)))
+Case conversion may be inaccurate. Consider using '#align thickened_indicator_subset thickenedIndicator_subsetₓ'. -/
 theorem thickenedIndicator_subset {δ : ℝ} (δ_pos : 0 < δ) {E₁ E₂ : Set α} (subset : E₁ ⊆ E₂) :
     ⇑(thickenedIndicator δ_pos E₁) ≤ thickenedIndicator δ_pos E₂ := fun x =>
   (toNNReal_le_toNNReal thickenedIndicatorAux_lt_top.Ne thickenedIndicatorAux_lt_top.Ne).mpr
     (thickenedIndicatorAux_subset δ subset x)
 #align thickened_indicator_subset thickenedIndicator_subset
 
+/- warning: thickened_indicator_tendsto_indicator_closure -> thickenedIndicator_tendsto_indicator_closure is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δseq : Nat -> Real} (δseq_pos : forall (n : Nat), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (δseq n)), (Filter.Tendsto.{0, 0} Nat Real δseq (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) -> (forall (E : Set.{u1} α), Filter.Tendsto.{0, u1} Nat (α -> NNReal) (fun (n : Nat) => coeFn.{succ u1, succ u1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (fun (ᾰ : BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) => α -> NNReal) (BoundedContinuousFunction.hasCoeToFun.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) NNReal.pseudoMetricSpace) (thickenedIndicator.{u1} α _inst_1 (δseq n) (δseq_pos n) E)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} (α -> NNReal) (Pi.topologicalSpace.{u1, 0} α (fun (ᾰ : α) => NNReal) (fun (a : α) => NNReal.topologicalSpace)) (Set.indicator.{u1, 0} α NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))) (closure.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) E) (fun (x : α) => OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoEMetricSpace.{u1} α] {δseq : Nat -> Real} (δseq_pos : forall (n : Nat), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (δseq n)), (Filter.Tendsto.{0, 0} Nat Real δseq (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) -> (forall (E : Set.{u1} α), Filter.Tendsto.{0, u1} Nat (forall (ᾰ : α), (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (fun (n : Nat) => FunLike.coe.{succ u1, succ u1, 1} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α (fun (ᾰ : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (ContinuousMapClass.toFunLike.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (BoundedContinuousMapClass.toContinuousMapClass.{u1, u1, 0} (BoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal) α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal (BoundedContinuousFunction.instBoundedContinuousMapClassBoundedContinuousFunction.{u1, 0} α NNReal (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) instPseudoMetricSpaceNNReal))) (thickenedIndicator.{u1} α _inst_1 (δseq n) (δseq_pos n) E)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} (forall (ᾰ : α), (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (Pi.topologicalSpace.{u1, 0} α (fun (ᾰ : α) => (fun (a._@.Mathlib.Topology.ContinuousFunction.Bounded._hyg.904 : α) => NNReal) ᾰ) (fun (a : α) => NNReal.instTopologicalSpaceNNReal)) (Set.indicator.{u1, 0} α NNReal instNNRealZero (closure.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoEMetricSpace.toUniformSpace.{u1} α _inst_1)) E) (fun (x : α) => OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)))))
+Case conversion may be inaccurate. Consider using '#align thickened_indicator_tendsto_indicator_closure thickenedIndicator_tendsto_indicator_closureₓ'. -/
 /-- As the thickening radius δ tends to 0, the δ-thickened indicator of a set E (in α) tends
 pointwise to the indicator function of the closure of E.
 

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

@@ -66,7 +66,7 @@ theorem continuous_thickenedIndicatorAux {δ : ℝ} (δ_pos : 0 < δ) (E : Set 
   let f := fun x : α => (⟨1, inf_edist x E / ENNReal.ofReal δ⟩ : ℝ≥0 × ℝ≥0∞)
   let sub := fun p : ℝ≥0 × ℝ≥0∞ => (p.1 : ℝ≥0∞) - p.2
   rw [show (fun x : α => (1 : ℝ≥0∞) - inf_edist x E / ENNReal.ofReal δ) = sub ∘ f by rfl]
-  apply (@ENNReal.continuous_nNReal_sub 1).comp
+  apply (@ENNReal.continuous_nnreal_sub 1).comp
   apply (ENNReal.continuous_div_const (ENNReal.ofReal δ) _).comp continuous_inf_edist
   norm_num [δ_pos]
 #align continuous_thickened_indicator_aux continuous_thickenedIndicatorAux

mathlib commit https://github.com/leanprover-community/mathlib/commit/195fcd60ff2bfe392543bceb0ec2adcdb472db4c

@@ -47,7 +47,7 @@ open NNReal ENNReal Set Metric Emetric Filter
 
 section thickenedIndicator
 
-variable {α : Type _} [PseudoEmetricSpace α]
+variable {α : Type _} [PseudoEMetricSpace α]
 
 /-- The `δ`-thickened indicator of a set `E` is the function that equals `1` on `E`
 and `0` outside a `δ`-thickening of `E` and interpolates (continuously) between

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

@@ -41,9 +41,9 @@ members of the approximating sequence are nonnegative bounded continuous functio
 
 noncomputable section
 
-open Classical NNReal Ennreal Topology BoundedContinuousFunction
+open Classical NNReal ENNReal Topology BoundedContinuousFunction
 
-open NNReal Ennreal Set Metric Emetric Filter
+open NNReal ENNReal Set Metric Emetric Filter
 
 section thickenedIndicator
 
@@ -56,18 +56,18 @@ these values using `inf_edist _ E`.
 `thickened_indicator_aux` is the unbundled `ℝ≥0∞`-valued function. See `thickened_indicator`
 for the (bundled) bounded continuous function with `ℝ≥0`-values. -/
 def thickenedIndicatorAux (δ : ℝ) (E : Set α) : α → ℝ≥0∞ := fun x : α =>
-  (1 : ℝ≥0∞) - infEdist x E / Ennreal.ofReal δ
+  (1 : ℝ≥0∞) - infEdist x E / ENNReal.ofReal δ
 #align thickened_indicator_aux thickenedIndicatorAux
 
 theorem continuous_thickenedIndicatorAux {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) :
     Continuous (thickenedIndicatorAux δ E) :=
   by
   unfold thickenedIndicatorAux
-  let f := fun x : α => (⟨1, inf_edist x E / Ennreal.ofReal δ⟩ : ℝ≥0 × ℝ≥0∞)
+  let f := fun x : α => (⟨1, inf_edist x E / ENNReal.ofReal δ⟩ : ℝ≥0 × ℝ≥0∞)
   let sub := fun p : ℝ≥0 × ℝ≥0∞ => (p.1 : ℝ≥0∞) - p.2
-  rw [show (fun x : α => (1 : ℝ≥0∞) - inf_edist x E / Ennreal.ofReal δ) = sub ∘ f by rfl]
-  apply (@Ennreal.continuous_nNReal_sub 1).comp
-  apply (Ennreal.continuous_div_const (Ennreal.ofReal δ) _).comp continuous_inf_edist
+  rw [show (fun x : α => (1 : ℝ≥0∞) - inf_edist x E / ENNReal.ofReal δ) = sub ∘ f by rfl]
+  apply (@ENNReal.continuous_nNReal_sub 1).comp
+  apply (ENNReal.continuous_div_const (ENNReal.ofReal δ) _).comp continuous_inf_edist
   norm_num [δ_pos]
 #align continuous_thickened_indicator_aux continuous_thickenedIndicatorAux
 
@@ -101,14 +101,14 @@ theorem thickenedIndicatorAux_zero {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x
   rw [thickening, mem_set_of_eq, not_lt] at x_out
   unfold thickenedIndicatorAux
   apply le_antisymm _ bot_le
-  have key := tsub_le_tsub (@rfl _ (1 : ℝ≥0∞)).le (Ennreal.div_le_div x_out rfl.le)
-  rw [Ennreal.div_self (ne_of_gt (ennreal.of_real_pos.mpr δ_pos)) of_real_ne_top] at key
+  have key := tsub_le_tsub (@rfl _ (1 : ℝ≥0∞)).le (ENNReal.div_le_div x_out rfl.le)
+  rw [ENNReal.div_self (ne_of_gt (ennreal.of_real_pos.mpr δ_pos)) of_real_ne_top] at key
   simpa using key
 #align thickened_indicator_aux_zero thickenedIndicatorAux_zero
 
 theorem thickenedIndicatorAux_mono {δ₁ δ₂ : ℝ} (hle : δ₁ ≤ δ₂) (E : Set α) :
     thickenedIndicatorAux δ₁ E ≤ thickenedIndicatorAux δ₂ E := fun _ =>
-  tsub_le_tsub (@rfl ℝ≥0∞ 1).le (Ennreal.div_le_div rfl.le (ofReal_le_ofReal hle))
+  tsub_le_tsub (@rfl ℝ≥0∞ 1).le (ENNReal.div_le_div rfl.le (ofReal_le_ofReal hle))
 #align thickened_indicator_aux_mono thickenedIndicatorAux_mono
 
 theorem indicator_le_thickenedIndicatorAux (δ : ℝ) (E : Set α) :
@@ -122,7 +122,7 @@ theorem indicator_le_thickenedIndicatorAux (δ : ℝ) (E : Set α) :
 
 theorem thickenedIndicatorAux_subset (δ : ℝ) {E₁ E₂ : Set α} (subset : E₁ ⊆ E₂) :
     thickenedIndicatorAux δ E₁ ≤ thickenedIndicatorAux δ E₂ := fun _ =>
-  tsub_le_tsub (@rfl ℝ≥0∞ 1).le (Ennreal.div_le_div (infEdist_anti subset) rfl.le)
+  tsub_le_tsub (@rfl ℝ≥0∞ 1).le (ENNReal.div_le_div (infEdist_anti subset) rfl.le)
 #align thickened_indicator_aux_subset thickenedIndicatorAux_subset
 
 /-- As the thickening radius δ tends to 0, the δ-thickened indicator of a set E (in α) tends
@@ -190,7 +190,7 @@ def thickenedIndicator {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) : α →ᵇ ℝ
 #align thickened_indicator thickenedIndicator
 
 theorem thickenedIndicator.coeFn_eq_comp {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) :
-    ⇑(thickenedIndicator δ_pos E) = Ennreal.toNnreal ∘ thickenedIndicatorAux δ E :=
+    ⇑(thickenedIndicator δ_pos E) = ENNReal.toNNReal ∘ thickenedIndicatorAux δ E :=
   rfl
 #align thickened_indicator.coe_fn_eq_comp thickenedIndicator.coeFn_eq_comp
 
@@ -238,7 +238,7 @@ theorem thickenedIndicator_mono {δ₁ δ₂ : ℝ} (δ₁_pos : 0 < δ₁) (δ
 
 theorem thickenedIndicator_subset {δ : ℝ} (δ_pos : 0 < δ) {E₁ E₂ : Set α} (subset : E₁ ⊆ E₂) :
     ⇑(thickenedIndicator δ_pos E₁) ≤ thickenedIndicator δ_pos E₂ := fun x =>
-  (toNnreal_le_toNnreal thickenedIndicatorAux_lt_top.Ne thickenedIndicatorAux_lt_top.Ne).mpr
+  (toNNReal_le_toNNReal thickenedIndicatorAux_lt_top.Ne thickenedIndicatorAux_lt_top.Ne).mpr
     (thickenedIndicatorAux_subset δ subset x)
 #align thickened_indicator_subset thickenedIndicator_subset
 
@@ -259,7 +259,7 @@ theorem thickenedIndicator_tendsto_indicator_closure {δseq : ℕ → ℝ} (δse
   rw [show
       indicator (closure E) (fun x => (1 : ℝ≥0)) x =
         (indicator (closure E) (fun x => (1 : ℝ≥0∞)) x).toNNReal
-      by refine' (congr_fun (comp_indicator_const 1 Ennreal.toNnreal zero_to_nnreal) x).symm]
+      by refine' (congr_fun (comp_indicator_const 1 ENNReal.toNNReal zero_to_nnreal) x).symm]
   refine' tendsto.comp (tendsto_to_nnreal _) (key x)
   by_cases x_mem : x ∈ closure E <;> simp [x_mem]
 #align thickened_indicator_tendsto_indicator_closure thickenedIndicator_tendsto_indicator_closure

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

We remove all but one open Classicals, instead preferring to use open scoped Classical. The only real side-effect this led to is moving a couple declarations to use Exists.choose instead of Classical.choose.

The first few commits are explicitly labelled regex replaces for ease of review.

@@ -36,7 +36,8 @@ members of the approximating sequence are nonnegative bounded continuous functio
 -/
 
 
-open Classical NNReal ENNReal Topology BoundedContinuousFunction
+open scoped Classical
+open NNReal ENNReal Topology BoundedContinuousFunction
 
 open NNReal ENNReal Set Metric EMetric Filter
 

This is a very large PR, but it has been reviewed piecemeal already in PRs to the bump/v4.7.0 branch as we update to intermediate nightlies.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: damiano <adomani@gmail.com>

@@ -62,7 +62,7 @@ theorem continuous_thickenedIndicatorAux {δ : ℝ} (δ_pos : 0 < δ) (E : Set 
   rw [show (fun x : α => (1 : ℝ≥0∞) - infEdist x E / ENNReal.ofReal δ) = sub ∘ f by rfl]
   apply (@ENNReal.continuous_nnreal_sub 1).comp
   apply (ENNReal.continuous_div_const (ENNReal.ofReal δ) _).comp continuous_infEdist
-  norm_num [δ_pos]
+  set_option tactic.skipAssignedInstances false in norm_num [δ_pos]
 #align continuous_thickened_indicator_aux continuous_thickenedIndicatorAux
 
 theorem thickenedIndicatorAux_le_one (δ : ℝ) (E : Set α) (x : α) :

I replaced a few "terminal" refine/refine's with exact.

The strategy was very simple-minded: essentially any refine whose following line had smaller indentation got replaced by exact and then I cleaned up the mess.

This PR certainly leaves some further terminal refines, but maybe the current change is beneficial.

@@ -175,7 +175,7 @@ def thickenedIndicator {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) : α →ᵇ ℝ
     have key := @thickenedIndicatorAux_le_one _ _ δ E
     apply add_le_add <;>
       · norm_cast
-        refine' (toNNReal_le_toNNReal (lt_of_le_of_lt (key _) one_lt_top).ne one_ne_top).mpr (key _)
+        exact (toNNReal_le_toNNReal (lt_of_le_of_lt (key _) one_lt_top).ne one_ne_top).mpr (key _)
 #align thickened_indicator thickenedIndicator
 
 theorem thickenedIndicator.coeFn_eq_comp {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) :

The file was becoming a bit large (1550 lines). Split in two files of about 900 and 700 lines: the first file contains more basic material, the second file contains all material related to thickenings.

Extend the module docstrings by mentioning the main results in this file.

@@ -5,7 +5,7 @@ Authors: Kalle Kytölä
 -/
 import Mathlib.Data.ENNReal.Basic
 import Mathlib.Topology.ContinuousFunction.Bounded
-import Mathlib.Topology.MetricSpace.HausdorffDistance
+import Mathlib.Topology.MetricSpace.Thickening
 
 #align_import topology.metric_space.thickened_indicator from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
 

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,6 @@ Authors: Kalle Kytölä
 import Mathlib.Data.ENNReal.Basic
 import Mathlib.Topology.ContinuousFunction.Bounded
 import Mathlib.Topology.MetricSpace.HausdorffDistance
-import Mathlib.Order.Filter.IndicatorFunction
 
 #align_import topology.metric_space.thickened_indicator from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
 

In preparation for splitting that file. Location suggested by @j-loreaux on zulip.

@@ -3,7 +3,7 @@ Copyright (c) 2022 Kalle Kytölä. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kalle Kytölä
 -/
-import Mathlib.Data.Real.ENNReal
+import Mathlib.Data.ENNReal.Basic
 import Mathlib.Topology.ContinuousFunction.Bounded
 import Mathlib.Topology.MetricSpace.HausdorffDistance
 import Mathlib.Order.Filter.IndicatorFunction

This PR adds a type class HasOuterApproxClosed for topological spaces in which indicator functions of closed sets can be approximated from above by sequences of bounded continuous functions. All pseudo-(e)metrizable spaces satisfy this.

In spaces with this property, finite Borel measures are characterized by the integrals of bounded continuous functions. Also weak limits of finite Borel measures are unique. More precisely, the topologies of weak convergence of finite Borel measures and of Borel probability measures are Hausdorff.

Co-authored-by: Peter Pfaffelhuber <p.p@stochastik.uni-freiburg.de>

Co-authored-by: kkytola <39528102+kkytola@users.noreply.github.com> Co-authored-by: kkytola <“kalle.kytola@aalto.fi”>

@@ -196,6 +196,16 @@ theorem thickenedIndicator_one_of_mem_closure {δ : ℝ} (δ_pos : 0 < δ) (E :
   rw [thickenedIndicator_apply, thickenedIndicatorAux_one_of_mem_closure δ E x_mem, one_toNNReal]
 #align thickened_indicator_one_of_mem_closure thickenedIndicator_one_of_mem_closure
 
+lemma one_le_thickenedIndicator_apply' {X : Type _} [PseudoEMetricSpace X]
+    {δ : ℝ} (δ_pos : 0 < δ) {F : Set X} {x : X} (hxF : x ∈ closure F) :
+    1 ≤ thickenedIndicator δ_pos F x := by
+  rw [thickenedIndicator_one_of_mem_closure δ_pos F hxF]
+
+lemma one_le_thickenedIndicator_apply (X : Type _) [PseudoEMetricSpace X]
+    {δ : ℝ} (δ_pos : 0 < δ) {F : Set X} {x : X} (hxF : x ∈ F) :
+    1 ≤ thickenedIndicator δ_pos F x :=
+  one_le_thickenedIndicator_apply' δ_pos (subset_closure hxF)
+
 theorem thickenedIndicator_one {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : α} (x_in_E : x ∈ E) :
     thickenedIndicator δ_pos E x = 1 :=
   thickenedIndicator_one_of_mem_closure _ _ (subset_closure x_in_E)

I've also got a change to make this required, but I'd like to land this first.

@@ -110,7 +110,7 @@ theorem thickenedIndicatorAux_mono {δ₁ δ₂ : ℝ} (hle : δ₁ ≤ δ₂) (
 theorem indicator_le_thickenedIndicatorAux (δ : ℝ) (E : Set α) :
     (E.indicator fun _ => (1 : ℝ≥0∞)) ≤ thickenedIndicatorAux δ E := by
   intro a
-  by_cases a ∈ E
+  by_cases h : a ∈ E
   · simp only [h, indicator_of_mem, thickenedIndicatorAux_one δ E h, le_refl]
   · simp only [h, indicator_of_not_mem, not_false_iff, zero_le]
 #align indicator_le_thickened_indicator_aux indicator_le_thickenedIndicatorAux
@@ -209,7 +209,7 @@ theorem thickenedIndicator_zero {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : 
 theorem indicator_le_thickenedIndicator {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) :
     (E.indicator fun _ => (1 : ℝ≥0)) ≤ thickenedIndicator δ_pos E := by
   intro a
-  by_cases a ∈ E
+  by_cases h : a ∈ E
   · simp only [h, indicator_of_mem, thickenedIndicator_one δ_pos E h, le_refl]
   · simp only [h, indicator_of_not_mem, not_false_iff, zero_le]
 #align indicator_le_thickened_indicator indicator_le_thickenedIndicator

PR contents

This is the supremum of

• #8284
• #8056
• #8023
• #8332
• #8226 (already approved)
• #7834 (already approved)

along with some minor fixes from failures on nightly-testing as Mathlib master is merged into it.

Note that some PRs for changes that are already compatible with the current toolchain and will be necessary have already been split out: #8380.

I am hopeful that in future we will be able to progressively merge adaptation PRs into a bump/v4.X.0 branch, so we never end up with a "big merge" like this. However one of these adaptation PRs (#8056) predates my new scheme for combined CI, and it wasn't possible to keep that PR viable in the meantime.

Lean PRs involved in this bump

In particular this includes adjustments for the Lean PRs

• leanprover/lean4#2778
• leanprover/lean4#2790
• leanprover/lean4#2783
• leanprover/lean4#2825
• leanprover/lean4#2722

leanprover/lean4#2778

We can get rid of all the

local macro_rules | `($x ^ $y) => `(HPow.hPow $x $y) -- Porting note: See issue [lean4#2220](https://github.com/leanprover/lean4/pull/2220)

macros across Mathlib (and in any projects that want to write natural number powers of reals).

leanprover/lean4#2722

Changes the default behaviour of simp to (config := {decide := false}). This makes simp (and consequentially norm_num) less powerful, but also more consistent, and less likely to blow up in long failures. This requires a variety of changes: changing some previously by simp or norm_num to decide or rfl, or adding (config := {decide := true}).

leanprover/lean4#2783

This changed the behaviour of simp so that simp [f] will only unfold "fully applied" occurrences of f. The old behaviour can be recovered with simp (config := { unfoldPartialApp := true }). We may in future add a syntax for this, e.g. simp [!f]; please provide feedback! In the meantime, we have made the following changes:

• switching to using explicit lemmas that have the intended level of application
• (config := { unfoldPartialApp := true }) in some places, to recover the old behaviour
• Using @[eqns] to manually adjust the equation lemmas for a particular definition, recovering the old behaviour just for that definition. See #8371, where we do this for Function.comp and Function.flip.

This change in Lean may require further changes down the line (e.g. adding the !f syntax, and/or upstreaming the special treatment for Function.comp and Function.flip, and/or removing this special treatment). Please keep an open and skeptical mind about these changes!

Co-authored-by: leanprover-community-mathlib4-bot <leanprover-community-mathlib4-bot@users.noreply.github.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Mauricio Collares <mauricio@collares.org>

@@ -78,7 +78,7 @@ theorem thickenedIndicatorAux_lt_top {δ : ℝ} {E : Set α} {x : α} :
 
 theorem thickenedIndicatorAux_closure_eq (δ : ℝ) (E : Set α) :
     thickenedIndicatorAux δ (closure E) = thickenedIndicatorAux δ E := by
-  simp_rw [thickenedIndicatorAux, infEdist_closure]
+  simp (config := { unfoldPartialApp := true }) only [thickenedIndicatorAux, infEdist_closure]
 #align thickened_indicator_aux_closure_eq thickenedIndicatorAux_closure_eq
 
 theorem thickenedIndicatorAux_one (δ : ℝ) (E : Set α) {x : α} (x_in_E : x ∈ E) :

norm_num was passing the wrong syntax node to elabSimpArgs when elaborating, which essentially had the effect of ignoring all arguments it was passed, i.e. norm_num [add_comm] would not try to commute addition in the simp step. The fix itself is very simple (though not obvious to debug!), probably using TSyntax more would help avoid such issues in future.

Due to this bug many norm_num [blah] became rw [blah]; norm_num or similar, sometimes with porting notes, sometimes not, we fix these porting notes and other regressions during the port also.

Interestingly cancel_denoms uses norm_num [<- mul_assoc] internally, so cancel_denoms also got stronger with this change.

@@ -63,8 +63,7 @@ theorem continuous_thickenedIndicatorAux {δ : ℝ} (δ_pos : 0 < δ) (E : Set 
   rw [show (fun x : α => (1 : ℝ≥0∞) - infEdist x E / ENNReal.ofReal δ) = sub ∘ f by rfl]
   apply (@ENNReal.continuous_nnreal_sub 1).comp
   apply (ENNReal.continuous_div_const (ENNReal.ofReal δ) _).comp continuous_infEdist
-  norm_num
-  exact δ_pos
+  norm_num [δ_pos]
 #align continuous_thickened_indicator_aux continuous_thickenedIndicatorAux
 
 theorem thickenedIndicatorAux_le_one (δ : ℝ) (E : Set α) (x : α) :

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

This has nice performance benefits.

@@ -43,7 +43,7 @@ open NNReal ENNReal Set Metric EMetric Filter
 
 noncomputable section thickenedIndicator
 
-variable {α : Type _} [PseudoEMetricSpace α]
+variable {α : Type*} [PseudoEMetricSpace α]
 
 /-- The `δ`-thickened indicator of a set `E` is the function that equals `1` on `E`
 and `0` outside a `δ`-thickening of `E` and interpolates (continuously) between
@@ -252,7 +252,7 @@ end thickenedIndicator
 
 section indicator
 
-variable {α : Type _} [PseudoEMetricSpace α] {β : Type _} [One β]
+variable {α : Type*} [PseudoEMetricSpace α] {β : Type*} [One β]
 
 /-- Pointwise, the multiplicative indicators of δ-thickenings of a set eventually coincide
 with the multiplicative indicator of the set as δ>0 tends to zero. -/

Add lemmas tendsto_indicator_thickening_indicator_closure and tendsto_indicator_cthickening_indicator_closure.

Co-authored-by: @sgouezel and @urkud

Co-authored-by: kkytola <39528102+kkytola@users.noreply.github.com>

@@ -6,6 +6,7 @@ Authors: Kalle Kytölä
 import Mathlib.Data.Real.ENNReal
 import Mathlib.Topology.ContinuousFunction.Bounded
 import Mathlib.Topology.MetricSpace.HausdorffDistance
+import Mathlib.Order.Filter.IndicatorFunction
 
 #align_import topology.metric_space.thickened_indicator from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
 
@@ -248,3 +249,64 @@ theorem thickenedIndicator_tendsto_indicator_closure {δseq : ℕ → ℝ} (δse
 #align thickened_indicator_tendsto_indicator_closure thickenedIndicator_tendsto_indicator_closure
 
 end thickenedIndicator
+
+section indicator
+
+variable {α : Type _} [PseudoEMetricSpace α] {β : Type _} [One β]
+
+/-- Pointwise, the multiplicative indicators of δ-thickenings of a set eventually coincide
+with the multiplicative indicator of the set as δ>0 tends to zero. -/
+@[to_additive "Pointwise, the indicators of δ-thickenings of a set eventually coincide
+with the indicator of the set as δ>0 tends to zero."]
+lemma mulIndicator_thickening_eventually_eq_mulIndicator_closure (f : α → β) (E : Set α) (x : α) :
+    ∀ᶠ δ in 𝓝[>] (0 : ℝ),
+      (Metric.thickening δ E).mulIndicator f x = (closure E).mulIndicator f x := by
+  by_cases x_mem_closure : x ∈ closure E
+  · filter_upwards [self_mem_nhdsWithin] with δ δ_pos
+    simp only [closure_subset_thickening δ_pos E x_mem_closure, mulIndicator_of_mem, x_mem_closure]
+  · have obs := eventually_not_mem_thickening_of_infEdist_pos x_mem_closure
+    filter_upwards [mem_nhdsWithin_of_mem_nhds obs, self_mem_nhdsWithin]
+      with δ x_notin_thE _
+    simp only [x_notin_thE, not_false_eq_true, mulIndicator_of_not_mem, x_mem_closure]
+
+/-- Pointwise, the multiplicative indicators of closed δ-thickenings of a set eventually coincide
+with the multiplicative indicator of the set as δ tends to zero. -/
+@[to_additive "Pointwise, the indicators of closed δ-thickenings of a set eventually coincide
+with the indicator of the set as δ tends to zero."]
+lemma mulIndicator_cthickening_eventually_eq_mulIndicator_closure (f : α → β) (E : Set α) (x : α) :
+    ∀ᶠ δ in 𝓝 (0 : ℝ),
+      (Metric.cthickening δ E).mulIndicator f x = (closure E).mulIndicator f x := by
+  by_cases x_mem_closure : x ∈ closure E
+  · filter_upwards [univ_mem] with δ _
+    have obs : x ∈ cthickening δ E := closure_subset_cthickening δ E x_mem_closure
+    rw [mulIndicator_of_mem obs f, mulIndicator_of_mem x_mem_closure f]
+  · filter_upwards [eventually_not_mem_cthickening_of_infEdist_pos x_mem_closure] with δ hδ
+    simp only [hδ, not_false_eq_true, mulIndicator_of_not_mem, x_mem_closure]
+
+variable [TopologicalSpace β]
+
+/-- The multiplicative indicators of δ-thickenings of a set tend pointwise to the multiplicative
+indicator of the set, as δ>0 tends to zero. -/
+@[to_additive "The indicators of δ-thickenings of a set tend pointwise to the indicator of the
+set, as δ>0 tends to zero."]
+lemma tendsto_mulIndicator_thickening_mulIndicator_closure (f : α → β) (E : Set α) :
+    Tendsto (fun δ ↦ (Metric.thickening δ E).mulIndicator f) (𝓝[>] 0)
+      (𝓝 ((closure E).mulIndicator f)) := by
+  rw [tendsto_pi_nhds]
+  intro x
+  rw [tendsto_congr' (mulIndicator_thickening_eventually_eq_mulIndicator_closure f E x)]
+  apply tendsto_const_nhds
+
+/-- The multiplicative indicators of closed δ-thickenings of a set tend pointwise to the
+multiplicative indicator of the set, as δ tends to zero. -/
+@[to_additive "The indicators of closed δ-thickenings of a set tend pointwise to the indicator
+of the set, as δ tends to zero."]
+lemma tendsto_mulIndicator_cthickening_mulIndicator_closure (f : α → β) (E : Set α) :
+    Tendsto (fun δ ↦ (Metric.cthickening δ E).mulIndicator f) (𝓝 0)
+      (𝓝 ((closure E).mulIndicator f)) := by
+  rw [tendsto_pi_nhds]
+  intro x
+  rw [tendsto_congr' (mulIndicator_cthickening_eventually_eq_mulIndicator_closure f E x)]
+  apply tendsto_const_nhds
+
+end indicator

• 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) 2022 Kalle Kytölä. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kalle Kytölä
-
-! This file was ported from Lean 3 source module topology.metric_space.thickened_indicator
-! 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.Data.Real.ENNReal
 import Mathlib.Topology.ContinuousFunction.Bounded
 import Mathlib.Topology.MetricSpace.HausdorffDistance
 
+#align_import topology.metric_space.thickened_indicator from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
+
 /-!
 # Thickened indicators