topology.support ⟷ Mathlib.Topology.Support

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

@@ -177,7 +177,7 @@ theorem hasCompactMulSupport_def : HasCompactMulSupport f ↔ IsCompact (closure
 #align has_compact_support_def hasCompactSupport_def
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (x «expr ∉ » K) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (x «expr ∉ » K) -/
 #print exists_compact_iff_hasCompactMulSupport /-
 @[to_additive]
 theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
@@ -188,7 +188,7 @@ theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
 #align exists_compact_iff_has_compact_support exists_compact_iff_hasCompactSupport
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (x «expr ∉ » K) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (x «expr ∉ » K) -/
 #print HasCompactMulSupport.intro /-
 @[to_additive]
 theorem HasCompactMulSupport.intro [T2Space α] {K : Set α} (hK : IsCompact K)

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

@@ -406,10 +406,10 @@ theorem exists_finset_nhd_mulSupport_subset {f : ι → X → R}
           (Set.not_mem_subset (hso j) (finset.mem_filter.mp hj).2)
   · exact (bInter_finset_mem is).mpr fun i hi => (ho i).mem_nhds (finset.mem_filter.mp hi).2
   · have hzn : z ∈ n := by
-      rw [inter_assoc] at hz 
+      rw [inter_assoc] at hz
       exact mem_of_mem_inter_left hz
     replace hz := mem_of_mem_inter_right (mem_of_mem_inter_left hz)
-    simp only [Finset.mem_filter, finite.mem_to_finset, mem_set_of_eq, mem_Inter, and_imp] at hz 
+    simp only [Finset.mem_filter, finite.mem_to_finset, mem_set_of_eq, mem_Inter, and_imp] at hz
     suffices (mul_support fun i => f i z) ⊆ hnf.to_finset
       by
       refine' hnf.to_finset.subset_coe_filter_of_subset_forall _ this fun i hi => _

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

@@ -394,6 +394,31 @@ theorem exists_finset_nhd_mulSupport_subset {f : ι → X → R}
   by
   obtain ⟨n, hn, hnf⟩ := hlf x
   classical
+  let is := hnf.to_finset.filter fun i => x ∈ U i
+  let js := hnf.to_finset.filter fun j => x ∉ U j
+  refine'
+    ⟨is, (n ∩ ⋂ j ∈ js, mulTSupport (f j)ᶜ) ∩ ⋂ i ∈ is, U i, inter_mem (inter_mem hn _) _,
+      inter_subset_right _ _, fun z hz => _⟩
+  ·
+    exact
+      (bInter_finset_mem js).mpr fun j hj =>
+        IsClosed.compl_mem_nhds (isClosed_mulTSupport _)
+          (Set.not_mem_subset (hso j) (finset.mem_filter.mp hj).2)
+  · exact (bInter_finset_mem is).mpr fun i hi => (ho i).mem_nhds (finset.mem_filter.mp hi).2
+  · have hzn : z ∈ n := by
+      rw [inter_assoc] at hz 
+      exact mem_of_mem_inter_left hz
+    replace hz := mem_of_mem_inter_right (mem_of_mem_inter_left hz)
+    simp only [Finset.mem_filter, finite.mem_to_finset, mem_set_of_eq, mem_Inter, and_imp] at hz 
+    suffices (mul_support fun i => f i z) ⊆ hnf.to_finset
+      by
+      refine' hnf.to_finset.subset_coe_filter_of_subset_forall _ this fun i hi => _
+      specialize hz i ⟨z, ⟨hi, hzn⟩⟩
+      contrapose hz
+      simp [hz, subset_mulTSupport (f i) hi]
+    intro i hi
+    simp only [finite.coe_to_finset, mem_set_of_eq]
+    exact ⟨z, ⟨hi, hzn⟩⟩
 #align locally_finite.exists_finset_nhd_mul_support_subset LocallyFinite.exists_finset_nhd_mulSupport_subset
 #align locally_finite.exists_finset_nhd_support_subset LocallyFinite.exists_finset_nhd_support_subset
 -/

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

@@ -183,7 +183,7 @@ theorem hasCompactMulSupport_def : HasCompactMulSupport f ↔ IsCompact (closure
 theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
     (∃ K : Set α, IsCompact K ∧ ∀ (x) (_ : x ∉ K), f x = 1) ↔ HasCompactMulSupport f := by
   simp_rw [← nmem_mul_support, ← mem_compl_iff, ← subset_def, compl_subset_compl,
-    hasCompactMulSupport_def, exists_compact_superset_iff]
+    hasCompactMulSupport_def, exists_isCompact_superset_iff]
 #align exists_compact_iff_has_compact_mul_support exists_compact_iff_hasCompactMulSupport
 #align exists_compact_iff_has_compact_support exists_compact_iff_hasCompactSupport
 -/
@@ -394,31 +394,6 @@ theorem exists_finset_nhd_mulSupport_subset {f : ι → X → R}
   by
   obtain ⟨n, hn, hnf⟩ := hlf x
   classical
-  let is := hnf.to_finset.filter fun i => x ∈ U i
-  let js := hnf.to_finset.filter fun j => x ∉ U j
-  refine'
-    ⟨is, (n ∩ ⋂ j ∈ js, mulTSupport (f j)ᶜ) ∩ ⋂ i ∈ is, U i, inter_mem (inter_mem hn _) _,
-      inter_subset_right _ _, fun z hz => _⟩
-  ·
-    exact
-      (bInter_finset_mem js).mpr fun j hj =>
-        IsClosed.compl_mem_nhds (isClosed_mulTSupport _)
-          (Set.not_mem_subset (hso j) (finset.mem_filter.mp hj).2)
-  · exact (bInter_finset_mem is).mpr fun i hi => (ho i).mem_nhds (finset.mem_filter.mp hi).2
-  · have hzn : z ∈ n := by
-      rw [inter_assoc] at hz 
-      exact mem_of_mem_inter_left hz
-    replace hz := mem_of_mem_inter_right (mem_of_mem_inter_left hz)
-    simp only [Finset.mem_filter, finite.mem_to_finset, mem_set_of_eq, mem_Inter, and_imp] at hz 
-    suffices (mul_support fun i => f i z) ⊆ hnf.to_finset
-      by
-      refine' hnf.to_finset.subset_coe_filter_of_subset_forall _ this fun i hi => _
-      specialize hz i ⟨z, ⟨hi, hzn⟩⟩
-      contrapose hz
-      simp [hz, subset_mulTSupport (f i) hi]
-    intro i hi
-    simp only [finite.coe_to_finset, mem_set_of_eq]
-    exact ⟨z, ⟨hi, hzn⟩⟩
 #align locally_finite.exists_finset_nhd_mul_support_subset LocallyFinite.exists_finset_nhd_mulSupport_subset
 #align locally_finite.exists_finset_nhd_support_subset LocallyFinite.exists_finset_nhd_support_subset
 -/

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

@@ -101,7 +101,7 @@ theorem range_subset_insert_image_mulTSupport (f : X → α) :
 @[to_additive]
 theorem range_eq_image_mulTSupport_or (f : X → α) :
     range f = f '' mulTSupport f ∨ range f = insert 1 (f '' mulTSupport f) :=
-  (wcovby_insert _ _).eq_or_eq (image_subset_range _ _) (range_subset_insert_image_mulTSupport f)
+  (wcovBy_insert _ _).eq_or_eq (image_subset_range _ _) (range_subset_insert_image_mulTSupport f)
 #align range_eq_image_mul_tsupport_or range_eq_image_mulTSupport_or
 #align range_eq_image_tsupport_or range_eq_image_tsupport_or
 -/

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

@@ -140,7 +140,7 @@ variable {g : β → γ} {f : α → β} {f₂ : α → γ} {m : β → γ → 
 #print not_mem_mulTSupport_iff_eventuallyEq /-
 @[to_additive]
 theorem not_mem_mulTSupport_iff_eventuallyEq : x ∉ mulTSupport f ↔ f =ᶠ[𝓝 x] 1 := by
-  simp_rw [mulTSupport, mem_closure_iff_nhds, not_forall, not_nonempty_iff_eq_empty, ←
+  simp_rw [mulTSupport, mem_closure_iff_nhds, Classical.not_forall, not_nonempty_iff_eq_empty, ←
     disjoint_iff_inter_eq_empty, disjoint_mul_support_iff, eventually_eq_iff_exists_mem]
 #align not_mem_mul_tsupport_iff_eventually_eq not_mem_mulTSupport_iff_eventuallyEq
 #align not_mem_tsupport_iff_eventually_eq not_mem_tsupport_iff_eventuallyEq

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

@@ -3,7 +3,7 @@ Copyright (c) 2022 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn, Patrick Massot
 -/
-import Mathbin.Topology.Separation
+import Topology.Separation
 
 #align_import topology.support from "leanprover-community/mathlib"@"0ebfdb71919ac6ca5d7fbc61a082fa2519556818"
 
@@ -177,7 +177,7 @@ theorem hasCompactMulSupport_def : HasCompactMulSupport f ↔ IsCompact (closure
 #align has_compact_support_def hasCompactSupport_def
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (x «expr ∉ » K) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (x «expr ∉ » K) -/
 #print exists_compact_iff_hasCompactMulSupport /-
 @[to_additive]
 theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
@@ -188,7 +188,7 @@ theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
 #align exists_compact_iff_has_compact_support exists_compact_iff_hasCompactSupport
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (x «expr ∉ » K) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (x «expr ∉ » K) -/
 #print HasCompactMulSupport.intro /-
 @[to_additive]
 theorem HasCompactMulSupport.intro [T2Space α] {K : Set α} (hK : IsCompact K)
@@ -216,7 +216,7 @@ theorem hasCompactMulSupport_iff_eventuallyEq :
         not_imp_comm.mpr fun hx => subset_mulTSupport f hx⟩,
     fun h =>
     let ⟨C, hC⟩ := mem_coclosed_compact'.mp h
-    isCompact_of_isClosed_subset hC.2.1 (isClosed_mulTSupport _) (closure_minimal hC.2.2 hC.1)⟩
+    IsCompact.of_isClosed_subset hC.2.1 (isClosed_mulTSupport _) (closure_minimal hC.2.2 hC.1)⟩
 #align has_compact_mul_support_iff_eventually_eq hasCompactMulSupport_iff_eventuallyEq
 #align has_compact_support_iff_eventually_eq hasCompactSupport_iff_eventuallyEq
 -/
@@ -236,7 +236,7 @@ theorem HasCompactMulSupport.isCompact_range [TopologicalSpace β] (h : HasCompa
 @[to_additive]
 theorem HasCompactMulSupport.mono' {f' : α → γ} (hf : HasCompactMulSupport f)
     (hff' : mulSupport f' ⊆ mulTSupport f) : HasCompactMulSupport f' :=
-  isCompact_of_isClosed_subset hf isClosed_closure <| closure_minimal hff' isClosed_closure
+  IsCompact.of_isClosed_subset hf isClosed_closure <| closure_minimal hff' isClosed_closure
 #align has_compact_mul_support.mono' HasCompactMulSupport.mono'
 #align has_compact_support.mono' HasCompactSupport.mono'
 -/
@@ -274,7 +274,7 @@ theorem HasCompactMulSupport.comp_closedEmbedding (hf : HasCompactMulSupport f)
     (hg : ClosedEmbedding g) : HasCompactMulSupport (f ∘ g) :=
   by
   rw [hasCompactMulSupport_def, Function.mulSupport_comp_eq_preimage]
-  refine' isCompact_of_isClosed_subset (hg.is_compact_preimage hf) isClosed_closure _
+  refine' IsCompact.of_isClosed_subset (hg.is_compact_preimage hf) isClosed_closure _
   rw [hg.to_embedding.closure_eq_preimage_closure_image]
   exact preimage_mono (closure_mono <| image_preimage_subset _ _)
 #align has_compact_mul_support.comp_closed_embedding HasCompactMulSupport.comp_closedEmbedding

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

@@ -2,14 +2,11 @@
 Copyright (c) 2022 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn, Patrick Massot
-
-! This file was ported from Lean 3 source module topology.support
-! leanprover-community/mathlib commit 0ebfdb71919ac6ca5d7fbc61a082fa2519556818
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Topology.Separation
 
+#align_import topology.support from "leanprover-community/mathlib"@"0ebfdb71919ac6ca5d7fbc61a082fa2519556818"
+
 /-!
 # The topological support of a function
 
@@ -180,7 +177,7 @@ theorem hasCompactMulSupport_def : HasCompactMulSupport f ↔ IsCompact (closure
 #align has_compact_support_def hasCompactSupport_def
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (x «expr ∉ » K) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (x «expr ∉ » K) -/
 #print exists_compact_iff_hasCompactMulSupport /-
 @[to_additive]
 theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
@@ -191,7 +188,7 @@ theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
 #align exists_compact_iff_has_compact_support exists_compact_iff_hasCompactSupport
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (x «expr ∉ » K) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (x «expr ∉ » K) -/
 #print HasCompactMulSupport.intro /-
 @[to_additive]
 theorem HasCompactMulSupport.intro [T2Space α] {K : Set α} (hK : IsCompact K)

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

@@ -58,29 +58,37 @@ def mulTSupport (f : X → α) : Set X :=
 #align tsupport tsupport
 -/
 
+#print subset_mulTSupport /-
 @[to_additive]
 theorem subset_mulTSupport (f : X → α) : mulSupport f ⊆ mulTSupport f :=
   subset_closure
 #align subset_mul_tsupport subset_mulTSupport
 #align subset_tsupport subset_tsupport
+-/
 
+#print isClosed_mulTSupport /-
 @[to_additive]
 theorem isClosed_mulTSupport (f : X → α) : IsClosed (mulTSupport f) :=
   isClosed_closure
 #align is_closed_mul_tsupport isClosed_mulTSupport
 #align is_closed_tsupport isClosed_tsupport
+-/
 
+#print mulTSupport_eq_empty_iff /-
 @[to_additive]
 theorem mulTSupport_eq_empty_iff {f : X → α} : mulTSupport f = ∅ ↔ f = 1 := by
   rw [mulTSupport, closure_empty_iff, mul_support_eq_empty_iff]
 #align mul_tsupport_eq_empty_iff mulTSupport_eq_empty_iff
 #align tsupport_eq_empty_iff tsupport_eq_empty_iff
+-/
 
+#print image_eq_one_of_nmem_mulTSupport /-
 @[to_additive]
 theorem image_eq_one_of_nmem_mulTSupport {f : X → α} {x : X} (hx : x ∉ mulTSupport f) : f x = 1 :=
   mulSupport_subset_iff'.mp (subset_mulTSupport f) x hx
 #align image_eq_one_of_nmem_mul_tsupport image_eq_one_of_nmem_mulTSupport
 #align image_eq_zero_of_nmem_tsupport image_eq_zero_of_nmem_tsupport
+-/
 
 #print range_subset_insert_image_mulTSupport /-
 @[to_additive]
@@ -101,22 +109,28 @@ theorem range_eq_image_mulTSupport_or (f : X → α) :
 #align range_eq_image_tsupport_or range_eq_image_tsupport_or
 -/
 
+#print tsupport_mul_subset_left /-
 theorem tsupport_mul_subset_left {α : Type _} [MulZeroClass α] {f g : X → α} :
     (tsupport fun x => f x * g x) ⊆ tsupport f :=
   closure_mono (support_mul_subset_left _ _)
 #align tsupport_mul_subset_left tsupport_mul_subset_left
+-/
 
+#print tsupport_mul_subset_right /-
 theorem tsupport_mul_subset_right {α : Type _} [MulZeroClass α] {f g : X → α} :
     (tsupport fun x => f x * g x) ⊆ tsupport g :=
   closure_mono (support_mul_subset_right _ _)
 #align tsupport_mul_subset_right tsupport_mul_subset_right
+-/
 
 end One
 
+#print tsupport_smul_subset_left /-
 theorem tsupport_smul_subset_left {M α} [TopologicalSpace X] [Zero M] [Zero α] [SMulWithZero M α]
     (f : X → M) (g : X → α) : (tsupport fun x => f x • g x) ⊆ tsupport f :=
   closure_mono <| support_smul_subset_left f g
 #align tsupport_smul_subset_left tsupport_smul_subset_left
+-/
 
 section
 
@@ -126,12 +140,14 @@ variable [One β] [One γ] [One δ]
 
 variable {g : β → γ} {f : α → β} {f₂ : α → γ} {m : β → γ → δ} {x : α}
 
+#print not_mem_mulTSupport_iff_eventuallyEq /-
 @[to_additive]
 theorem not_mem_mulTSupport_iff_eventuallyEq : x ∉ mulTSupport f ↔ f =ᶠ[𝓝 x] 1 := by
   simp_rw [mulTSupport, mem_closure_iff_nhds, not_forall, not_nonempty_iff_eq_empty, ←
     disjoint_iff_inter_eq_empty, disjoint_mul_support_iff, eventually_eq_iff_exists_mem]
 #align not_mem_mul_tsupport_iff_eventually_eq not_mem_mulTSupport_iff_eventuallyEq
 #align not_mem_tsupport_iff_eventually_eq not_mem_tsupport_iff_eventuallyEq
+-/
 
 #print continuous_of_mulTSupport /-
 @[to_additive]
@@ -156,13 +172,16 @@ def HasCompactMulSupport (f : α → β) : Prop :=
 #align has_compact_support HasCompactSupport
 -/
 
+#print hasCompactMulSupport_def /-
 @[to_additive]
 theorem hasCompactMulSupport_def : HasCompactMulSupport f ↔ IsCompact (closure (mulSupport f)) := by
   rfl
 #align has_compact_mul_support_def hasCompactMulSupport_def
 #align has_compact_support_def hasCompactSupport_def
+-/
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (x «expr ∉ » K) -/
+#print exists_compact_iff_hasCompactMulSupport /-
 @[to_additive]
 theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
     (∃ K : Set α, IsCompact K ∧ ∀ (x) (_ : x ∉ K), f x = 1) ↔ HasCompactMulSupport f := by
@@ -170,21 +189,27 @@ theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
     hasCompactMulSupport_def, exists_compact_superset_iff]
 #align exists_compact_iff_has_compact_mul_support exists_compact_iff_hasCompactMulSupport
 #align exists_compact_iff_has_compact_support exists_compact_iff_hasCompactSupport
+-/
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (x «expr ∉ » K) -/
+#print HasCompactMulSupport.intro /-
 @[to_additive]
 theorem HasCompactMulSupport.intro [T2Space α] {K : Set α} (hK : IsCompact K)
     (hfK : ∀ (x) (_ : x ∉ K), f x = 1) : HasCompactMulSupport f :=
   exists_compact_iff_hasCompactMulSupport.mp ⟨K, hK, hfK⟩
 #align has_compact_mul_support.intro HasCompactMulSupport.intro
 #align has_compact_support.intro HasCompactSupport.intro
+-/
 
+#print HasCompactMulSupport.isCompact /-
 @[to_additive]
 theorem HasCompactMulSupport.isCompact (hf : HasCompactMulSupport f) : IsCompact (mulTSupport f) :=
   hf
 #align has_compact_mul_support.is_compact HasCompactMulSupport.isCompact
 #align has_compact_support.is_compact HasCompactSupport.isCompact
+-/
 
+#print hasCompactMulSupport_iff_eventuallyEq /-
 @[to_additive]
 theorem hasCompactMulSupport_iff_eventuallyEq :
     HasCompactMulSupport f ↔ f =ᶠ[coclosedCompact α] 1 :=
@@ -197,6 +222,7 @@ theorem hasCompactMulSupport_iff_eventuallyEq :
     isCompact_of_isClosed_subset hC.2.1 (isClosed_mulTSupport _) (closure_minimal hC.2.2 hC.1)⟩
 #align has_compact_mul_support_iff_eventually_eq hasCompactMulSupport_iff_eventuallyEq
 #align has_compact_support_iff_eventually_eq hasCompactSupport_iff_eventuallyEq
+-/
 
 #print HasCompactMulSupport.isCompact_range /-
 @[to_additive]
@@ -209,26 +235,32 @@ theorem HasCompactMulSupport.isCompact_range [TopologicalSpace β] (h : HasCompa
 #align has_compact_support.is_compact_range HasCompactSupport.isCompact_range
 -/
 
+#print HasCompactMulSupport.mono' /-
 @[to_additive]
 theorem HasCompactMulSupport.mono' {f' : α → γ} (hf : HasCompactMulSupport f)
     (hff' : mulSupport f' ⊆ mulTSupport f) : HasCompactMulSupport f' :=
   isCompact_of_isClosed_subset hf isClosed_closure <| closure_minimal hff' isClosed_closure
 #align has_compact_mul_support.mono' HasCompactMulSupport.mono'
 #align has_compact_support.mono' HasCompactSupport.mono'
+-/
 
+#print HasCompactMulSupport.mono /-
 @[to_additive]
 theorem HasCompactMulSupport.mono {f' : α → γ} (hf : HasCompactMulSupport f)
     (hff' : mulSupport f' ⊆ mulSupport f) : HasCompactMulSupport f' :=
   hf.mono' <| hff'.trans subset_closure
 #align has_compact_mul_support.mono HasCompactMulSupport.mono
 #align has_compact_support.mono HasCompactSupport.mono
+-/
 
+#print HasCompactMulSupport.comp_left /-
 @[to_additive]
 theorem HasCompactMulSupport.comp_left (hf : HasCompactMulSupport f) (hg : g 1 = 1) :
     HasCompactMulSupport (g ∘ f) :=
   hf.mono <| mulSupport_comp_subset hg f
 #align has_compact_mul_support.comp_left HasCompactMulSupport.comp_left
 #align has_compact_support.comp_left HasCompactSupport.comp_left
+-/
 
 #print hasCompactMulSupport_comp_left /-
 @[to_additive]
@@ -239,6 +271,7 @@ theorem hasCompactMulSupport_comp_left (hg : ∀ {x}, g x = 1 ↔ x = 1) :
 #align has_compact_support_comp_left hasCompactSupport_comp_left
 -/
 
+#print HasCompactMulSupport.comp_closedEmbedding /-
 @[to_additive]
 theorem HasCompactMulSupport.comp_closedEmbedding (hf : HasCompactMulSupport f) {g : α' → α}
     (hg : ClosedEmbedding g) : HasCompactMulSupport (f ∘ g) :=
@@ -249,7 +282,9 @@ theorem HasCompactMulSupport.comp_closedEmbedding (hf : HasCompactMulSupport f)
   exact preimage_mono (closure_mono <| image_preimage_subset _ _)
 #align has_compact_mul_support.comp_closed_embedding HasCompactMulSupport.comp_closedEmbedding
 #align has_compact_support.comp_closed_embedding HasCompactSupport.comp_closedEmbedding
+-/
 
+#print HasCompactMulSupport.comp₂_left /-
 @[to_additive]
 theorem HasCompactMulSupport.comp₂_left (hf : HasCompactMulSupport f)
     (hf₂ : HasCompactMulSupport f₂) (hm : m 1 1 = 1) :
@@ -259,6 +294,7 @@ theorem HasCompactMulSupport.comp₂_left (hf : HasCompactMulSupport f)
   filter_upwards [hf, hf₂] using fun x hx hx₂ => by simp_rw [hx, hx₂, Pi.one_apply, hm]
 #align has_compact_mul_support.comp₂_left HasCompactMulSupport.comp₂_left
 #align has_compact_support.comp₂_left HasCompactSupport.comp₂_left
+-/
 
 end
 
@@ -268,11 +304,13 @@ variable [TopologicalSpace α] [Monoid β]
 
 variable {f f' : α → β} {x : α}
 
+#print HasCompactMulSupport.mul /-
 @[to_additive]
 theorem HasCompactMulSupport.mul (hf : HasCompactMulSupport f) (hf' : HasCompactMulSupport f') :
     HasCompactMulSupport (f * f') := by apply hf.comp₂_left hf' (mul_one 1)
 #align has_compact_mul_support.mul HasCompactMulSupport.mul
 #align has_compact_support.add HasCompactSupport.add
+-/
 
 -- `by apply` speeds up elaboration
 end Monoid
@@ -283,11 +321,13 @@ variable [TopologicalSpace α] [MonoidWithZero R] [AddMonoid M] [DistribMulActio
 
 variable {f : α → R} {f' : α → M} {x : α}
 
+#print HasCompactSupport.smul_left /-
 theorem HasCompactSupport.smul_left (hf : HasCompactSupport f') : HasCompactSupport (f • f') :=
   by
   rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
   refine' hf.mono fun x hx => by simp_rw [Pi.smul_apply', hx, Pi.zero_apply, smul_zero]
 #align has_compact_support.smul_left HasCompactSupport.smul_left
+-/
 
 end DistribMulAction
 
@@ -297,17 +337,21 @@ variable [TopologicalSpace α] [Zero R] [Zero M] [SMulWithZero R M]
 
 variable {f : α → R} {f' : α → M} {x : α}
 
+#print HasCompactSupport.smul_right /-
 theorem HasCompactSupport.smul_right (hf : HasCompactSupport f) : HasCompactSupport (f • f') :=
   by
   rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
   refine' hf.mono fun x hx => by simp_rw [Pi.smul_apply', hx, Pi.zero_apply, zero_smul]
 #align has_compact_support.smul_right HasCompactSupport.smul_right
+-/
 
+#print HasCompactSupport.smul_left' /-
 theorem HasCompactSupport.smul_left' (hf : HasCompactSupport f') : HasCompactSupport (f • f') :=
   by
   rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
   refine' hf.mono fun x hx => by simp_rw [Pi.smul_apply', hx, Pi.zero_apply, smul_zero]
 #align has_compact_support.smul_left' HasCompactSupport.smul_left'
+-/
 
 end SMulWithZero
 
@@ -317,17 +361,21 @@ variable [TopologicalSpace α] [MulZeroClass β]
 
 variable {f f' : α → β} {x : α}
 
+#print HasCompactSupport.mul_right /-
 theorem HasCompactSupport.mul_right (hf : HasCompactSupport f) : HasCompactSupport (f * f') :=
   by
   rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
   refine' hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, MulZeroClass.zero_mul]
 #align has_compact_support.mul_right HasCompactSupport.mul_right
+-/
 
+#print HasCompactSupport.mul_left /-
 theorem HasCompactSupport.mul_left (hf : HasCompactSupport f') : HasCompactSupport (f * f') :=
   by
   rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
   refine' hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, MulZeroClass.mul_zero]
 #align has_compact_support.mul_left HasCompactSupport.mul_left
+-/
 
 end MulZeroClass
 
@@ -335,6 +383,7 @@ namespace LocallyFinite
 
 variable {ι : Type _} {U : ι → Set X} [TopologicalSpace X] [One R]
 
+#print LocallyFinite.exists_finset_nhd_mulSupport_subset /-
 /-- If a family of functions `f` has locally-finite multiplicative support, subordinate to a family
 of open sets, then for any point we can find a neighbourhood on which only finitely-many members of
 `f` are not equal to 1. -/
@@ -375,6 +424,7 @@ theorem exists_finset_nhd_mulSupport_subset {f : ι → X → R}
     exact ⟨z, ⟨hi, hzn⟩⟩
 #align locally_finite.exists_finset_nhd_mul_support_subset LocallyFinite.exists_finset_nhd_mulSupport_subset
 #align locally_finite.exists_finset_nhd_support_subset LocallyFinite.exists_finset_nhd_support_subset
+-/
 
 end LocallyFinite
 

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

@@ -162,7 +162,7 @@ theorem hasCompactMulSupport_def : HasCompactMulSupport f ↔ IsCompact (closure
 #align has_compact_mul_support_def hasCompactMulSupport_def
 #align has_compact_support_def hasCompactSupport_def
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (x «expr ∉ » K) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (x «expr ∉ » K) -/
 @[to_additive]
 theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
     (∃ K : Set α, IsCompact K ∧ ∀ (x) (_ : x ∉ K), f x = 1) ↔ HasCompactMulSupport f := by
@@ -171,7 +171,7 @@ theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
 #align exists_compact_iff_has_compact_mul_support exists_compact_iff_hasCompactMulSupport
 #align exists_compact_iff_has_compact_support exists_compact_iff_hasCompactSupport
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (x «expr ∉ » K) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (x «expr ∉ » K) -/
 @[to_additive]
 theorem HasCompactMulSupport.intro [T2Space α] {K : Set α} (hK : IsCompact K)
     (hfK : ∀ (x) (_ : x ∉ K), f x = 1) : HasCompactMulSupport f :=

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

@@ -256,7 +256,7 @@ theorem HasCompactMulSupport.comp₂_left (hf : HasCompactMulSupport f)
     HasCompactMulSupport fun x => m (f x) (f₂ x) :=
   by
   rw [hasCompactMulSupport_iff_eventuallyEq] at hf hf₂ ⊢
-  filter_upwards [hf, hf₂]using fun x hx hx₂ => by simp_rw [hx, hx₂, Pi.one_apply, hm]
+  filter_upwards [hf, hf₂] using fun x hx hx₂ => by simp_rw [hx, hx₂, Pi.one_apply, hm]
 #align has_compact_mul_support.comp₂_left HasCompactMulSupport.comp₂_left
 #align has_compact_support.comp₂_left HasCompactSupport.comp₂_left
 
@@ -348,31 +348,31 @@ theorem exists_finset_nhd_mulSupport_subset {f : ι → X → R}
   by
   obtain ⟨n, hn, hnf⟩ := hlf x
   classical
-    let is := hnf.to_finset.filter fun i => x ∈ U i
-    let js := hnf.to_finset.filter fun j => x ∉ U j
-    refine'
-      ⟨is, (n ∩ ⋂ j ∈ js, mulTSupport (f j)ᶜ) ∩ ⋂ i ∈ is, U i, inter_mem (inter_mem hn _) _,
-        inter_subset_right _ _, fun z hz => _⟩
-    ·
-      exact
-        (bInter_finset_mem js).mpr fun j hj =>
-          IsClosed.compl_mem_nhds (isClosed_mulTSupport _)
-            (Set.not_mem_subset (hso j) (finset.mem_filter.mp hj).2)
-    · exact (bInter_finset_mem is).mpr fun i hi => (ho i).mem_nhds (finset.mem_filter.mp hi).2
-    · have hzn : z ∈ n := by
-        rw [inter_assoc] at hz 
-        exact mem_of_mem_inter_left hz
-      replace hz := mem_of_mem_inter_right (mem_of_mem_inter_left hz)
-      simp only [Finset.mem_filter, finite.mem_to_finset, mem_set_of_eq, mem_Inter, and_imp] at hz 
-      suffices (mul_support fun i => f i z) ⊆ hnf.to_finset
-        by
-        refine' hnf.to_finset.subset_coe_filter_of_subset_forall _ this fun i hi => _
-        specialize hz i ⟨z, ⟨hi, hzn⟩⟩
-        contrapose hz
-        simp [hz, subset_mulTSupport (f i) hi]
-      intro i hi
-      simp only [finite.coe_to_finset, mem_set_of_eq]
-      exact ⟨z, ⟨hi, hzn⟩⟩
+  let is := hnf.to_finset.filter fun i => x ∈ U i
+  let js := hnf.to_finset.filter fun j => x ∉ U j
+  refine'
+    ⟨is, (n ∩ ⋂ j ∈ js, mulTSupport (f j)ᶜ) ∩ ⋂ i ∈ is, U i, inter_mem (inter_mem hn _) _,
+      inter_subset_right _ _, fun z hz => _⟩
+  ·
+    exact
+      (bInter_finset_mem js).mpr fun j hj =>
+        IsClosed.compl_mem_nhds (isClosed_mulTSupport _)
+          (Set.not_mem_subset (hso j) (finset.mem_filter.mp hj).2)
+  · exact (bInter_finset_mem is).mpr fun i hi => (ho i).mem_nhds (finset.mem_filter.mp hi).2
+  · have hzn : z ∈ n := by
+      rw [inter_assoc] at hz 
+      exact mem_of_mem_inter_left hz
+    replace hz := mem_of_mem_inter_right (mem_of_mem_inter_left hz)
+    simp only [Finset.mem_filter, finite.mem_to_finset, mem_set_of_eq, mem_Inter, and_imp] at hz 
+    suffices (mul_support fun i => f i z) ⊆ hnf.to_finset
+      by
+      refine' hnf.to_finset.subset_coe_filter_of_subset_forall _ this fun i hi => _
+      specialize hz i ⟨z, ⟨hi, hzn⟩⟩
+      contrapose hz
+      simp [hz, subset_mulTSupport (f i) hi]
+    intro i hi
+    simp only [finite.coe_to_finset, mem_set_of_eq]
+    exact ⟨z, ⟨hi, hzn⟩⟩
 #align locally_finite.exists_finset_nhd_mul_support_subset LocallyFinite.exists_finset_nhd_mulSupport_subset
 #align locally_finite.exists_finset_nhd_support_subset LocallyFinite.exists_finset_nhd_support_subset
 

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

@@ -204,7 +204,7 @@ theorem HasCompactMulSupport.isCompact_range [TopologicalSpace β] (h : HasCompa
     (hf : Continuous f) : IsCompact (range f) :=
   by
   cases' range_eq_image_mulTSupport_or f with h2 h2 <;> rw [h2]
-  exacts[h.image hf, (h.image hf).insert 1]
+  exacts [h.image hf, (h.image hf).insert 1]
 #align has_compact_mul_support.is_compact_range HasCompactMulSupport.isCompact_range
 #align has_compact_support.is_compact_range HasCompactSupport.isCompact_range
 -/
@@ -255,7 +255,7 @@ theorem HasCompactMulSupport.comp₂_left (hf : HasCompactMulSupport f)
     (hf₂ : HasCompactMulSupport f₂) (hm : m 1 1 = 1) :
     HasCompactMulSupport fun x => m (f x) (f₂ x) :=
   by
-  rw [hasCompactMulSupport_iff_eventuallyEq] at hf hf₂⊢
+  rw [hasCompactMulSupport_iff_eventuallyEq] at hf hf₂ ⊢
   filter_upwards [hf, hf₂]using fun x hx hx₂ => by simp_rw [hx, hx₂, Pi.one_apply, hm]
 #align has_compact_mul_support.comp₂_left HasCompactMulSupport.comp₂_left
 #align has_compact_support.comp₂_left HasCompactSupport.comp₂_left
@@ -285,7 +285,7 @@ variable {f : α → R} {f' : α → M} {x : α}
 
 theorem HasCompactSupport.smul_left (hf : HasCompactSupport f') : HasCompactSupport (f • f') :=
   by
-  rw [hasCompactSupport_iff_eventuallyEq] at hf⊢
+  rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
   refine' hf.mono fun x hx => by simp_rw [Pi.smul_apply', hx, Pi.zero_apply, smul_zero]
 #align has_compact_support.smul_left HasCompactSupport.smul_left
 
@@ -299,13 +299,13 @@ variable {f : α → R} {f' : α → M} {x : α}
 
 theorem HasCompactSupport.smul_right (hf : HasCompactSupport f) : HasCompactSupport (f • f') :=
   by
-  rw [hasCompactSupport_iff_eventuallyEq] at hf⊢
+  rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
   refine' hf.mono fun x hx => by simp_rw [Pi.smul_apply', hx, Pi.zero_apply, zero_smul]
 #align has_compact_support.smul_right HasCompactSupport.smul_right
 
 theorem HasCompactSupport.smul_left' (hf : HasCompactSupport f') : HasCompactSupport (f • f') :=
   by
-  rw [hasCompactSupport_iff_eventuallyEq] at hf⊢
+  rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
   refine' hf.mono fun x hx => by simp_rw [Pi.smul_apply', hx, Pi.zero_apply, smul_zero]
 #align has_compact_support.smul_left' HasCompactSupport.smul_left'
 
@@ -319,13 +319,13 @@ variable {f f' : α → β} {x : α}
 
 theorem HasCompactSupport.mul_right (hf : HasCompactSupport f) : HasCompactSupport (f * f') :=
   by
-  rw [hasCompactSupport_iff_eventuallyEq] at hf⊢
+  rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
   refine' hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, MulZeroClass.zero_mul]
 #align has_compact_support.mul_right HasCompactSupport.mul_right
 
 theorem HasCompactSupport.mul_left (hf : HasCompactSupport f') : HasCompactSupport (f * f') :=
   by
-  rw [hasCompactSupport_iff_eventuallyEq] at hf⊢
+  rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
   refine' hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, MulZeroClass.mul_zero]
 #align has_compact_support.mul_left HasCompactSupport.mul_left
 
@@ -343,7 +343,7 @@ of open sets, then for any point we can find a neighbourhood on which only finit
 theorem exists_finset_nhd_mulSupport_subset {f : ι → X → R}
     (hlf : LocallyFinite fun i => mulSupport (f i)) (hso : ∀ i, mulTSupport (f i) ⊆ U i)
     (ho : ∀ i, IsOpen (U i)) (x : X) :
-    ∃ (is : Finset ι)(n : Set X)(hn₁ : n ∈ 𝓝 x)(hn₂ : n ⊆ ⋂ i ∈ is, U i),
+    ∃ (is : Finset ι) (n : Set X) (hn₁ : n ∈ 𝓝 x) (hn₂ : n ⊆ ⋂ i ∈ is, U i),
       ∀ z ∈ n, (mulSupport fun i => f i z) ⊆ is :=
   by
   obtain ⟨n, hn, hnf⟩ := hlf x
@@ -360,10 +360,10 @@ theorem exists_finset_nhd_mulSupport_subset {f : ι → X → R}
             (Set.not_mem_subset (hso j) (finset.mem_filter.mp hj).2)
     · exact (bInter_finset_mem is).mpr fun i hi => (ho i).mem_nhds (finset.mem_filter.mp hi).2
     · have hzn : z ∈ n := by
-        rw [inter_assoc] at hz
+        rw [inter_assoc] at hz 
         exact mem_of_mem_inter_left hz
       replace hz := mem_of_mem_inter_right (mem_of_mem_inter_left hz)
-      simp only [Finset.mem_filter, finite.mem_to_finset, mem_set_of_eq, mem_Inter, and_imp] at hz
+      simp only [Finset.mem_filter, finite.mem_to_finset, mem_set_of_eq, mem_Inter, and_imp] at hz 
       suffices (mul_support fun i => f i z) ⊆ hnf.to_finset
         by
         refine' hnf.to_finset.subset_coe_filter_of_subset_forall _ this fun i hi => _

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

@@ -37,7 +37,7 @@ Furthermore, we say that `f` has compact support if the topological support of `
 
 open Function Set Filter
 
-open Topology
+open scoped Topology
 
 variable {X α α' β γ δ M E R : Type _}
 

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

@@ -58,48 +58,24 @@ def mulTSupport (f : X → α) : Set X :=
 #align tsupport tsupport
 -/
 
-/- warning: subset_mul_tsupport -> subset_mulTSupport is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {α : Type.{u2}} [_inst_1 : One.{u2} α] [_inst_2 : TopologicalSpace.{u1} X] (f : X -> α), HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) (Function.mulSupport.{u1, u2} X α _inst_1 f) (mulTSupport.{u1, u2} X α _inst_1 _inst_2 f)
-but is expected to have type
-  forall {X : Type.{u2}} {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : TopologicalSpace.{u2} X] (f : X -> α), HasSubset.Subset.{u2} (Set.{u2} X) (Set.instHasSubsetSet.{u2} X) (Function.mulSupport.{u2, u1} X α _inst_1 f) (mulTSupport.{u2, u1} X α _inst_1 _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align subset_mul_tsupport subset_mulTSupportₓ'. -/
 @[to_additive]
 theorem subset_mulTSupport (f : X → α) : mulSupport f ⊆ mulTSupport f :=
   subset_closure
 #align subset_mul_tsupport subset_mulTSupport
 #align subset_tsupport subset_tsupport
 
-/- warning: is_closed_mul_tsupport -> isClosed_mulTSupport is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {α : Type.{u2}} [_inst_1 : One.{u2} α] [_inst_2 : TopologicalSpace.{u1} X] (f : X -> α), IsClosed.{u1} X _inst_2 (mulTSupport.{u1, u2} X α _inst_1 _inst_2 f)
-but is expected to have type
-  forall {X : Type.{u2}} {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : TopologicalSpace.{u2} X] (f : X -> α), IsClosed.{u2} X _inst_2 (mulTSupport.{u2, u1} X α _inst_1 _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align is_closed_mul_tsupport isClosed_mulTSupportₓ'. -/
 @[to_additive]
 theorem isClosed_mulTSupport (f : X → α) : IsClosed (mulTSupport f) :=
   isClosed_closure
 #align is_closed_mul_tsupport isClosed_mulTSupport
 #align is_closed_tsupport isClosed_tsupport
 
-/- warning: mul_tsupport_eq_empty_iff -> mulTSupport_eq_empty_iff is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {α : Type.{u2}} [_inst_1 : One.{u2} α] [_inst_2 : TopologicalSpace.{u1} X] {f : X -> α}, Iff (Eq.{succ u1} (Set.{u1} X) (mulTSupport.{u1, u2} X α _inst_1 _inst_2 f) (EmptyCollection.emptyCollection.{u1} (Set.{u1} X) (Set.hasEmptyc.{u1} X))) (Eq.{max (succ u1) (succ u2)} (X -> α) f (OfNat.ofNat.{max u1 u2} (X -> α) 1 (OfNat.mk.{max u1 u2} (X -> α) 1 (One.one.{max u1 u2} (X -> α) (Pi.instOne.{u1, u2} X (fun (ᾰ : X) => α) (fun (i : X) => _inst_1))))))
-but is expected to have type
-  forall {X : Type.{u2}} {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : TopologicalSpace.{u2} X] {f : X -> α}, Iff (Eq.{succ u2} (Set.{u2} X) (mulTSupport.{u2, u1} X α _inst_1 _inst_2 f) (EmptyCollection.emptyCollection.{u2} (Set.{u2} X) (Set.instEmptyCollectionSet.{u2} X))) (Eq.{max (succ u2) (succ u1)} (X -> α) f (OfNat.ofNat.{max u2 u1} (X -> α) 1 (One.toOfNat1.{max u2 u1} (X -> α) (Pi.instOne.{u2, u1} X (fun (a._@.Mathlib.Topology.Support._hyg.142 : X) => α) (fun (i : X) => _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align mul_tsupport_eq_empty_iff mulTSupport_eq_empty_iffₓ'. -/
 @[to_additive]
 theorem mulTSupport_eq_empty_iff {f : X → α} : mulTSupport f = ∅ ↔ f = 1 := by
   rw [mulTSupport, closure_empty_iff, mul_support_eq_empty_iff]
 #align mul_tsupport_eq_empty_iff mulTSupport_eq_empty_iff
 #align tsupport_eq_empty_iff tsupport_eq_empty_iff
 
-/- warning: image_eq_one_of_nmem_mul_tsupport -> image_eq_one_of_nmem_mulTSupport is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {α : Type.{u2}} [_inst_1 : One.{u2} α] [_inst_2 : TopologicalSpace.{u1} X] {f : X -> α} {x : X}, (Not (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x (mulTSupport.{u1, u2} X α _inst_1 _inst_2 f))) -> (Eq.{succ u2} α (f x) (OfNat.ofNat.{u2} α 1 (OfNat.mk.{u2} α 1 (One.one.{u2} α _inst_1))))
-but is expected to have type
-  forall {X : Type.{u2}} {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : TopologicalSpace.{u2} X] {f : X -> α} {x : X}, (Not (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) x (mulTSupport.{u2, u1} X α _inst_1 _inst_2 f))) -> (Eq.{succ u1} α (f x) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align image_eq_one_of_nmem_mul_tsupport image_eq_one_of_nmem_mulTSupportₓ'. -/
 @[to_additive]
 theorem image_eq_one_of_nmem_mulTSupport {f : X → α} {x : X} (hx : x ∉ mulTSupport f) : f x = 1 :=
   mulSupport_subset_iff'.mp (subset_mulTSupport f) x hx
@@ -125,23 +101,11 @@ theorem range_eq_image_mulTSupport_or (f : X → α) :
 #align range_eq_image_tsupport_or range_eq_image_tsupport_or
 -/
 
-/- warning: tsupport_mul_subset_left -> tsupport_mul_subset_left is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {α : Type.{u2}} [_inst_3 : MulZeroClass.{u2} α] {f : X -> α} {g : X -> α}, HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) (tsupport.{u1, u2} X α (MulZeroClass.toHasZero.{u2} α _inst_3) _inst_2 (fun (x : X) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulZeroClass.toHasMul.{u2} α _inst_3)) (f x) (g x))) (tsupport.{u1, u2} X α (MulZeroClass.toHasZero.{u2} α _inst_3) _inst_2 f)
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {α : Type.{u2}} [_inst_3 : MulZeroClass.{u2} α] {f : X -> α} {g : X -> α}, HasSubset.Subset.{u1} (Set.{u1} X) (Set.instHasSubsetSet.{u1} X) (tsupport.{u1, u2} X α (MulZeroClass.toZero.{u2} α _inst_3) _inst_2 (fun (x : X) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulZeroClass.toMul.{u2} α _inst_3)) (f x) (g x))) (tsupport.{u1, u2} X α (MulZeroClass.toZero.{u2} α _inst_3) _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align tsupport_mul_subset_left tsupport_mul_subset_leftₓ'. -/
 theorem tsupport_mul_subset_left {α : Type _} [MulZeroClass α] {f g : X → α} :
     (tsupport fun x => f x * g x) ⊆ tsupport f :=
   closure_mono (support_mul_subset_left _ _)
 #align tsupport_mul_subset_left tsupport_mul_subset_left
 
-/- warning: tsupport_mul_subset_right -> tsupport_mul_subset_right is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {α : Type.{u2}} [_inst_3 : MulZeroClass.{u2} α] {f : X -> α} {g : X -> α}, HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) (tsupport.{u1, u2} X α (MulZeroClass.toHasZero.{u2} α _inst_3) _inst_2 (fun (x : X) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulZeroClass.toHasMul.{u2} α _inst_3)) (f x) (g x))) (tsupport.{u1, u2} X α (MulZeroClass.toHasZero.{u2} α _inst_3) _inst_2 g)
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {α : Type.{u2}} [_inst_3 : MulZeroClass.{u2} α] {f : X -> α} {g : X -> α}, HasSubset.Subset.{u1} (Set.{u1} X) (Set.instHasSubsetSet.{u1} X) (tsupport.{u1, u2} X α (MulZeroClass.toZero.{u2} α _inst_3) _inst_2 (fun (x : X) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulZeroClass.toMul.{u2} α _inst_3)) (f x) (g x))) (tsupport.{u1, u2} X α (MulZeroClass.toZero.{u2} α _inst_3) _inst_2 g)
-Case conversion may be inaccurate. Consider using '#align tsupport_mul_subset_right tsupport_mul_subset_rightₓ'. -/
 theorem tsupport_mul_subset_right {α : Type _} [MulZeroClass α] {f g : X → α} :
     (tsupport fun x => f x * g x) ⊆ tsupport g :=
   closure_mono (support_mul_subset_right _ _)
@@ -149,12 +113,6 @@ theorem tsupport_mul_subset_right {α : Type _} [MulZeroClass α] {f g : X → 
 
 end One
 
-/- warning: tsupport_smul_subset_left -> tsupport_smul_subset_left is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {M : Type.{u2}} {α : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : Zero.{u2} M] [_inst_3 : Zero.{u3} α] [_inst_4 : SMulWithZero.{u2, u3} M α _inst_2 _inst_3] (f : X -> M) (g : X -> α), HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) (tsupport.{u1, u3} X α _inst_3 _inst_1 (fun (x : X) => SMul.smul.{u2, u3} M α (SMulZeroClass.toHasSmul.{u2, u3} M α _inst_3 (SMulWithZero.toSmulZeroClass.{u2, u3} M α _inst_2 _inst_3 _inst_4)) (f x) (g x))) (tsupport.{u1, u2} X M _inst_2 _inst_1 f)
-but is expected to have type
-  forall {X : Type.{u1}} {M : Type.{u3}} {α : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : Zero.{u3} M] [_inst_3 : Zero.{u2} α] [_inst_4 : SMulWithZero.{u3, u2} M α _inst_2 _inst_3] (f : X -> M) (g : X -> α), HasSubset.Subset.{u1} (Set.{u1} X) (Set.instHasSubsetSet.{u1} X) (tsupport.{u1, u2} X α _inst_3 _inst_1 (fun (x : X) => HSMul.hSMul.{u3, u2, u2} M α α (instHSMul.{u3, u2} M α (SMulZeroClass.toSMul.{u3, u2} M α _inst_3 (SMulWithZero.toSMulZeroClass.{u3, u2} M α _inst_2 _inst_3 _inst_4))) (f x) (g x))) (tsupport.{u1, u3} X M _inst_2 _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align tsupport_smul_subset_left tsupport_smul_subset_leftₓ'. -/
 theorem tsupport_smul_subset_left {M α} [TopologicalSpace X] [Zero M] [Zero α] [SMulWithZero M α]
     (f : X → M) (g : X → α) : (tsupport fun x => f x • g x) ⊆ tsupport f :=
   closure_mono <| support_smul_subset_left f g
@@ -168,12 +126,6 @@ variable [One β] [One γ] [One δ]
 
 variable {g : β → γ} {f : α → β} {f₂ : α → γ} {m : β → γ → δ} {x : α}
 
-/- warning: not_mem_mul_tsupport_iff_eventually_eq -> not_mem_mulTSupport_iff_eventuallyEq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : One.{u2} β] {f : α -> β} {x : α}, Iff (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (mulTSupport.{u1, u2} α β _inst_3 _inst_1 f))) (Filter.EventuallyEq.{u1, u2} α β (nhds.{u1} α _inst_1 x) f (OfNat.ofNat.{max u1 u2} (α -> β) 1 (OfNat.mk.{max u1 u2} (α -> β) 1 (One.one.{max u1 u2} (α -> β) (Pi.instOne.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_3))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_3 : One.{u1} β] {f : α -> β} {x : α}, Iff (Not (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) x (mulTSupport.{u2, u1} α β _inst_3 _inst_1 f))) (Filter.EventuallyEq.{u2, u1} α β (nhds.{u2} α _inst_1 x) f (OfNat.ofNat.{max u2 u1} (α -> β) 1 (One.toOfNat1.{max u2 u1} (α -> β) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19136 : α) => β) (fun (i : α) => _inst_3)))))
-Case conversion may be inaccurate. Consider using '#align not_mem_mul_tsupport_iff_eventually_eq not_mem_mulTSupport_iff_eventuallyEqₓ'. -/
 @[to_additive]
 theorem not_mem_mulTSupport_iff_eventuallyEq : x ∉ mulTSupport f ↔ f =ᶠ[𝓝 x] 1 := by
   simp_rw [mulTSupport, mem_closure_iff_nhds, not_forall, not_nonempty_iff_eq_empty, ←
@@ -204,24 +156,12 @@ def HasCompactMulSupport (f : α → β) : Prop :=
 #align has_compact_support HasCompactSupport
 -/
 
-/- warning: has_compact_mul_support_def -> hasCompactMulSupport_def is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : One.{u2} β] {f : α -> β}, Iff (HasCompactMulSupport.{u1, u2} α β _inst_1 _inst_3 f) (IsCompact.{u1} α _inst_1 (closure.{u1} α _inst_1 (Function.mulSupport.{u1, u2} α β _inst_3 f)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_3 : One.{u1} β] {f : α -> β}, Iff (HasCompactMulSupport.{u2, u1} α β _inst_1 _inst_3 f) (IsCompact.{u2} α _inst_1 (closure.{u2} α _inst_1 (Function.mulSupport.{u2, u1} α β _inst_3 f)))
-Case conversion may be inaccurate. Consider using '#align has_compact_mul_support_def hasCompactMulSupport_defₓ'. -/
 @[to_additive]
 theorem hasCompactMulSupport_def : HasCompactMulSupport f ↔ IsCompact (closure (mulSupport f)) := by
   rfl
 #align has_compact_mul_support_def hasCompactMulSupport_def
 #align has_compact_support_def hasCompactSupport_def
 
-/- warning: exists_compact_iff_has_compact_mul_support -> exists_compact_iff_hasCompactMulSupport is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : One.{u2} β] {f : α -> β} [_inst_6 : T2Space.{u1} α _inst_1], Iff (Exists.{succ u1} (Set.{u1} α) (fun (K : Set.{u1} α) => And (IsCompact.{u1} α _inst_1 K) (forall (x : α), (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x K)) -> (Eq.{succ u2} β (f x) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β _inst_3))))))) (HasCompactMulSupport.{u1, u2} α β _inst_1 _inst_3 f)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_3 : One.{u1} β] {f : α -> β} [_inst_6 : T2Space.{u2} α _inst_1], Iff (Exists.{succ u2} (Set.{u2} α) (fun (K : Set.{u2} α) => And (IsCompact.{u2} α _inst_1 K) (forall (x : α), (Not (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) x K)) -> (Eq.{succ u1} β (f x) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β _inst_3)))))) (HasCompactMulSupport.{u2, u1} α β _inst_1 _inst_3 f)
-Case conversion may be inaccurate. Consider using '#align exists_compact_iff_has_compact_mul_support exists_compact_iff_hasCompactMulSupportₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (x «expr ∉ » K) -/
 @[to_additive]
 theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
@@ -231,12 +171,6 @@ theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
 #align exists_compact_iff_has_compact_mul_support exists_compact_iff_hasCompactMulSupport
 #align exists_compact_iff_has_compact_support exists_compact_iff_hasCompactSupport
 
-/- warning: has_compact_mul_support.intro -> HasCompactMulSupport.intro is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : One.{u2} β] {f : α -> β} [_inst_6 : T2Space.{u1} α _inst_1] {K : Set.{u1} α}, (IsCompact.{u1} α _inst_1 K) -> (forall (x : α), (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x K)) -> (Eq.{succ u2} β (f x) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β _inst_3))))) -> (HasCompactMulSupport.{u1, u2} α β _inst_1 _inst_3 f)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_3 : One.{u1} β] {f : α -> β} [_inst_6 : T2Space.{u2} α _inst_1] {K : Set.{u2} α}, (IsCompact.{u2} α _inst_1 K) -> (forall (x : α), (Not (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) x K)) -> (Eq.{succ u1} β (f x) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β _inst_3)))) -> (HasCompactMulSupport.{u2, u1} α β _inst_1 _inst_3 f)
-Case conversion may be inaccurate. Consider using '#align has_compact_mul_support.intro HasCompactMulSupport.introₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (x «expr ∉ » K) -/
 @[to_additive]
 theorem HasCompactMulSupport.intro [T2Space α] {K : Set α} (hK : IsCompact K)
@@ -245,24 +179,12 @@ theorem HasCompactMulSupport.intro [T2Space α] {K : Set α} (hK : IsCompact K)
 #align has_compact_mul_support.intro HasCompactMulSupport.intro
 #align has_compact_support.intro HasCompactSupport.intro
 
-/- warning: has_compact_mul_support.is_compact -> HasCompactMulSupport.isCompact is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : One.{u2} β] {f : α -> β}, (HasCompactMulSupport.{u1, u2} α β _inst_1 _inst_3 f) -> (IsCompact.{u1} α _inst_1 (mulTSupport.{u1, u2} α β _inst_3 _inst_1 f))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_3 : One.{u1} β] {f : α -> β}, (HasCompactMulSupport.{u2, u1} α β _inst_1 _inst_3 f) -> (IsCompact.{u2} α _inst_1 (mulTSupport.{u2, u1} α β _inst_3 _inst_1 f))
-Case conversion may be inaccurate. Consider using '#align has_compact_mul_support.is_compact HasCompactMulSupport.isCompactₓ'. -/
 @[to_additive]
 theorem HasCompactMulSupport.isCompact (hf : HasCompactMulSupport f) : IsCompact (mulTSupport f) :=
   hf
 #align has_compact_mul_support.is_compact HasCompactMulSupport.isCompact
 #align has_compact_support.is_compact HasCompactSupport.isCompact
 
-/- warning: has_compact_mul_support_iff_eventually_eq -> hasCompactMulSupport_iff_eventuallyEq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : One.{u2} β] {f : α -> β}, Iff (HasCompactMulSupport.{u1, u2} α β _inst_1 _inst_3 f) (Filter.EventuallyEq.{u1, u2} α β (Filter.coclosedCompact.{u1} α _inst_1) f (OfNat.ofNat.{max u1 u2} (α -> β) 1 (OfNat.mk.{max u1 u2} (α -> β) 1 (One.one.{max u1 u2} (α -> β) (Pi.instOne.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_3))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_3 : One.{u1} β] {f : α -> β}, Iff (HasCompactMulSupport.{u2, u1} α β _inst_1 _inst_3 f) (Filter.EventuallyEq.{u2, u1} α β (Filter.coclosedCompact.{u2} α _inst_1) f (OfNat.ofNat.{max u2 u1} (α -> β) 1 (One.toOfNat1.{max u2 u1} (α -> β) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19136 : α) => β) (fun (i : α) => _inst_3)))))
-Case conversion may be inaccurate. Consider using '#align has_compact_mul_support_iff_eventually_eq hasCompactMulSupport_iff_eventuallyEqₓ'. -/
 @[to_additive]
 theorem hasCompactMulSupport_iff_eventuallyEq :
     HasCompactMulSupport f ↔ f =ᶠ[coclosedCompact α] 1 :=
@@ -287,12 +209,6 @@ theorem HasCompactMulSupport.isCompact_range [TopologicalSpace β] (h : HasCompa
 #align has_compact_support.is_compact_range HasCompactSupport.isCompact_range
 -/
 
-/- warning: has_compact_mul_support.mono' -> HasCompactMulSupport.mono' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : One.{u2} β] [_inst_4 : One.{u3} γ] {f : α -> β} {f' : α -> γ}, (HasCompactMulSupport.{u1, u2} α β _inst_1 _inst_3 f) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Function.mulSupport.{u1, u3} α γ _inst_4 f') (mulTSupport.{u1, u2} α β _inst_3 _inst_1 f)) -> (HasCompactMulSupport.{u1, u3} α γ _inst_1 _inst_4 f')
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_1 : TopologicalSpace.{u3} α] [_inst_3 : One.{u2} β] [_inst_4 : One.{u1} γ] {f : α -> β} {f' : α -> γ}, (HasCompactMulSupport.{u3, u2} α β _inst_1 _inst_3 f) -> (HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (Function.mulSupport.{u3, u1} α γ _inst_4 f') (mulTSupport.{u3, u2} α β _inst_3 _inst_1 f)) -> (HasCompactMulSupport.{u3, u1} α γ _inst_1 _inst_4 f')
-Case conversion may be inaccurate. Consider using '#align has_compact_mul_support.mono' HasCompactMulSupport.mono'ₓ'. -/
 @[to_additive]
 theorem HasCompactMulSupport.mono' {f' : α → γ} (hf : HasCompactMulSupport f)
     (hff' : mulSupport f' ⊆ mulTSupport f) : HasCompactMulSupport f' :=
@@ -300,12 +216,6 @@ theorem HasCompactMulSupport.mono' {f' : α → γ} (hf : HasCompactMulSupport f
 #align has_compact_mul_support.mono' HasCompactMulSupport.mono'
 #align has_compact_support.mono' HasCompactSupport.mono'
 
-/- warning: has_compact_mul_support.mono -> HasCompactMulSupport.mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : One.{u2} β] [_inst_4 : One.{u3} γ] {f : α -> β} {f' : α -> γ}, (HasCompactMulSupport.{u1, u2} α β _inst_1 _inst_3 f) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Function.mulSupport.{u1, u3} α γ _inst_4 f') (Function.mulSupport.{u1, u2} α β _inst_3 f)) -> (HasCompactMulSupport.{u1, u3} α γ _inst_1 _inst_4 f')
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_1 : TopologicalSpace.{u3} α] [_inst_3 : One.{u2} β] [_inst_4 : One.{u1} γ] {f : α -> β} {f' : α -> γ}, (HasCompactMulSupport.{u3, u2} α β _inst_1 _inst_3 f) -> (HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (Function.mulSupport.{u3, u1} α γ _inst_4 f') (Function.mulSupport.{u3, u2} α β _inst_3 f)) -> (HasCompactMulSupport.{u3, u1} α γ _inst_1 _inst_4 f')
-Case conversion may be inaccurate. Consider using '#align has_compact_mul_support.mono HasCompactMulSupport.monoₓ'. -/
 @[to_additive]
 theorem HasCompactMulSupport.mono {f' : α → γ} (hf : HasCompactMulSupport f)
     (hff' : mulSupport f' ⊆ mulSupport f) : HasCompactMulSupport f' :=
@@ -313,12 +223,6 @@ theorem HasCompactMulSupport.mono {f' : α → γ} (hf : HasCompactMulSupport f)
 #align has_compact_mul_support.mono HasCompactMulSupport.mono
 #align has_compact_support.mono HasCompactSupport.mono
 
-/- warning: has_compact_mul_support.comp_left -> HasCompactMulSupport.comp_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : One.{u2} β] [_inst_4 : One.{u3} γ] {g : β -> γ} {f : α -> β}, (HasCompactMulSupport.{u1, u2} α β _inst_1 _inst_3 f) -> (Eq.{succ u3} γ (g (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β _inst_3)))) (OfNat.ofNat.{u3} γ 1 (OfNat.mk.{u3} γ 1 (One.one.{u3} γ _inst_4)))) -> (HasCompactMulSupport.{u1, u3} α γ _inst_1 _inst_4 (Function.comp.{succ u1, succ u2, succ u3} α β γ g f))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_1 : TopologicalSpace.{u3} α] [_inst_3 : One.{u2} β] [_inst_4 : One.{u1} γ] {g : β -> γ} {f : α -> β}, (HasCompactMulSupport.{u3, u2} α β _inst_1 _inst_3 f) -> (Eq.{succ u1} γ (g (OfNat.ofNat.{u2} β 1 (One.toOfNat1.{u2} β _inst_3))) (OfNat.ofNat.{u1} γ 1 (One.toOfNat1.{u1} γ _inst_4))) -> (HasCompactMulSupport.{u3, u1} α γ _inst_1 _inst_4 (Function.comp.{succ u3, succ u2, succ u1} α β γ g f))
-Case conversion may be inaccurate. Consider using '#align has_compact_mul_support.comp_left HasCompactMulSupport.comp_leftₓ'. -/
 @[to_additive]
 theorem HasCompactMulSupport.comp_left (hf : HasCompactMulSupport f) (hg : g 1 = 1) :
     HasCompactMulSupport (g ∘ f) :=
@@ -335,12 +239,6 @@ theorem hasCompactMulSupport_comp_left (hg : ∀ {x}, g x = 1 ↔ x = 1) :
 #align has_compact_support_comp_left hasCompactSupport_comp_left
 -/
 
-/- warning: has_compact_mul_support.comp_closed_embedding -> HasCompactMulSupport.comp_closedEmbedding is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {α' : Type.{u2}} {β : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_2 : TopologicalSpace.{u2} α'] [_inst_3 : One.{u3} β] {f : α -> β}, (HasCompactMulSupport.{u1, u3} α β _inst_1 _inst_3 f) -> (forall {g : α' -> α}, (ClosedEmbedding.{u2, u1} α' α _inst_2 _inst_1 g) -> (HasCompactMulSupport.{u2, u3} α' β _inst_2 _inst_3 (Function.comp.{succ u2, succ u1, succ u3} α' α β f g)))
-but is expected to have type
-  forall {α : Type.{u3}} {α' : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u3} α] [_inst_2 : TopologicalSpace.{u1} α'] [_inst_3 : One.{u2} β] {f : α -> β}, (HasCompactMulSupport.{u3, u2} α β _inst_1 _inst_3 f) -> (forall {g : α' -> α}, (ClosedEmbedding.{u1, u3} α' α _inst_2 _inst_1 g) -> (HasCompactMulSupport.{u1, u2} α' β _inst_2 _inst_3 (Function.comp.{succ u1, succ u3, succ u2} α' α β f g)))
-Case conversion may be inaccurate. Consider using '#align has_compact_mul_support.comp_closed_embedding HasCompactMulSupport.comp_closedEmbeddingₓ'. -/
 @[to_additive]
 theorem HasCompactMulSupport.comp_closedEmbedding (hf : HasCompactMulSupport f) {g : α' → α}
     (hg : ClosedEmbedding g) : HasCompactMulSupport (f ∘ g) :=
@@ -352,12 +250,6 @@ theorem HasCompactMulSupport.comp_closedEmbedding (hf : HasCompactMulSupport f)
 #align has_compact_mul_support.comp_closed_embedding HasCompactMulSupport.comp_closedEmbedding
 #align has_compact_support.comp_closed_embedding HasCompactSupport.comp_closedEmbedding
 
-/- warning: has_compact_mul_support.comp₂_left -> HasCompactMulSupport.comp₂_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : One.{u2} β] [_inst_4 : One.{u3} γ] [_inst_5 : One.{u4} δ] {f : α -> β} {f₂ : α -> γ} {m : β -> γ -> δ}, (HasCompactMulSupport.{u1, u2} α β _inst_1 _inst_3 f) -> (HasCompactMulSupport.{u1, u3} α γ _inst_1 _inst_4 f₂) -> (Eq.{succ u4} δ (m (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β _inst_3))) (OfNat.ofNat.{u3} γ 1 (OfNat.mk.{u3} γ 1 (One.one.{u3} γ _inst_4)))) (OfNat.ofNat.{u4} δ 1 (OfNat.mk.{u4} δ 1 (One.one.{u4} δ _inst_5)))) -> (HasCompactMulSupport.{u1, u4} α δ _inst_1 _inst_5 (fun (x : α) => m (f x) (f₂ x)))
-but is expected to have type
-  forall {α : Type.{u4}} {β : Type.{u3}} {γ : Type.{u2}} {δ : Type.{u1}} [_inst_1 : TopologicalSpace.{u4} α] [_inst_3 : One.{u3} β] [_inst_4 : One.{u2} γ] [_inst_5 : One.{u1} δ] {f : α -> β} {f₂ : α -> γ} {m : β -> γ -> δ}, (HasCompactMulSupport.{u4, u3} α β _inst_1 _inst_3 f) -> (HasCompactMulSupport.{u4, u2} α γ _inst_1 _inst_4 f₂) -> (Eq.{succ u1} δ (m (OfNat.ofNat.{u3} β 1 (One.toOfNat1.{u3} β _inst_3)) (OfNat.ofNat.{u2} γ 1 (One.toOfNat1.{u2} γ _inst_4))) (OfNat.ofNat.{u1} δ 1 (One.toOfNat1.{u1} δ _inst_5))) -> (HasCompactMulSupport.{u4, u1} α δ _inst_1 _inst_5 (fun (x : α) => m (f x) (f₂ x)))
-Case conversion may be inaccurate. Consider using '#align has_compact_mul_support.comp₂_left HasCompactMulSupport.comp₂_leftₓ'. -/
 @[to_additive]
 theorem HasCompactMulSupport.comp₂_left (hf : HasCompactMulSupport f)
     (hf₂ : HasCompactMulSupport f₂) (hm : m 1 1 = 1) :
@@ -376,12 +268,6 @@ variable [TopologicalSpace α] [Monoid β]
 
 variable {f f' : α → β} {x : α}
 
-/- warning: has_compact_mul_support.mul -> HasCompactMulSupport.mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_2 : Monoid.{u2} β] {f : α -> β} {f' : α -> β}, (HasCompactMulSupport.{u1, u2} α β _inst_1 (MulOneClass.toHasOne.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) f) -> (HasCompactMulSupport.{u1, u2} α β _inst_1 (MulOneClass.toHasOne.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) f') -> (HasCompactMulSupport.{u1, u2} α β _inst_1 (MulOneClass.toHasOne.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)))) f f'))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_2 : Monoid.{u1} β] {f : α -> β} {f' : α -> β}, (HasCompactMulSupport.{u2, u1} α β _inst_1 (Monoid.toOne.{u1} β _inst_2) f) -> (HasCompactMulSupport.{u2, u1} α β _inst_1 (Monoid.toOne.{u1} β _inst_2) f') -> (HasCompactMulSupport.{u2, u1} α β _inst_1 (Monoid.toOne.{u1} β _inst_2) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_2)))) f f'))
-Case conversion may be inaccurate. Consider using '#align has_compact_mul_support.mul HasCompactMulSupport.mulₓ'. -/
 @[to_additive]
 theorem HasCompactMulSupport.mul (hf : HasCompactMulSupport f) (hf' : HasCompactMulSupport f') :
     HasCompactMulSupport (f * f') := by apply hf.comp₂_left hf' (mul_one 1)
@@ -397,12 +283,6 @@ variable [TopologicalSpace α] [MonoidWithZero R] [AddMonoid M] [DistribMulActio
 
 variable {f : α → R} {f' : α → M} {x : α}
 
-/- warning: has_compact_support.smul_left -> HasCompactSupport.smul_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} {R : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_2 : MonoidWithZero.{u3} R] [_inst_3 : AddMonoid.{u2} M] [_inst_4 : DistribMulAction.{u3, u2} R M (MonoidWithZero.toMonoid.{u3} R _inst_2) _inst_3] {f : α -> R} {f' : α -> M}, (HasCompactSupport.{u1, u2} α M _inst_1 (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M _inst_3)) f') -> (HasCompactSupport.{u1, u2} α M _inst_1 (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M _inst_3)) (SMul.smul.{max u1 u3, max u1 u2} (α -> R) (α -> M) (Pi.smul'.{u1, u3, u2} α (fun (ᾰ : α) => R) (fun (ᾰ : α) => M) (fun (i : α) => SMulZeroClass.toHasSmul.{u3, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M _inst_3)) (DistribSMul.toSmulZeroClass.{u3, u2} R M (AddMonoid.toAddZeroClass.{u2} M _inst_3) (DistribMulAction.toDistribSMul.{u3, u2} R M (MonoidWithZero.toMonoid.{u3} R _inst_2) _inst_3 _inst_4)))) f f'))
-but is expected to have type
-  forall {α : Type.{u3}} {M : Type.{u2}} {R : Type.{u1}} [_inst_1 : TopologicalSpace.{u3} α] [_inst_2 : MonoidWithZero.{u1} R] [_inst_3 : AddMonoid.{u2} M] [_inst_4 : DistribMulAction.{u1, u2} R M (MonoidWithZero.toMonoid.{u1} R _inst_2) _inst_3] {f : α -> R} {f' : α -> M}, (HasCompactSupport.{u3, u2} α M _inst_1 (AddMonoid.toZero.{u2} M _inst_3) f') -> (HasCompactSupport.{u3, u2} α M _inst_1 (AddMonoid.toZero.{u2} M _inst_3) (HSMul.hSMul.{max u3 u1, max u3 u2, max u3 u2} (α -> R) (α -> M) (α -> M) (instHSMul.{max u3 u1, max u3 u2} (α -> R) (α -> M) (Pi.smul'.{u3, u1, u2} α (fun (a._@.Mathlib.Topology.Support._hyg.2135 : α) => R) (fun (a._@.Mathlib.Topology.Support._hyg.2138 : α) => M) (fun (i : α) => SMulZeroClass.toSMul.{u1, u2} R M (AddMonoid.toZero.{u2} M _inst_3) (DistribSMul.toSMulZeroClass.{u1, u2} R M (AddMonoid.toAddZeroClass.{u2} M _inst_3) (DistribMulAction.toDistribSMul.{u1, u2} R M (MonoidWithZero.toMonoid.{u1} R _inst_2) _inst_3 _inst_4))))) f f'))
-Case conversion may be inaccurate. Consider using '#align has_compact_support.smul_left HasCompactSupport.smul_leftₓ'. -/
 theorem HasCompactSupport.smul_left (hf : HasCompactSupport f') : HasCompactSupport (f • f') :=
   by
   rw [hasCompactSupport_iff_eventuallyEq] at hf⊢
@@ -417,24 +297,12 @@ variable [TopologicalSpace α] [Zero R] [Zero M] [SMulWithZero R M]
 
 variable {f : α → R} {f' : α → M} {x : α}
 
-/- warning: has_compact_support.smul_right -> HasCompactSupport.smul_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} {R : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_2 : Zero.{u3} R] [_inst_3 : Zero.{u2} M] [_inst_4 : SMulWithZero.{u3, u2} R M _inst_2 _inst_3] {f : α -> R} {f' : α -> M}, (HasCompactSupport.{u1, u3} α R _inst_1 _inst_2 f) -> (HasCompactSupport.{u1, u2} α M _inst_1 _inst_3 (SMul.smul.{max u1 u3, max u1 u2} (α -> R) (α -> M) (Pi.smul'.{u1, u3, u2} α (fun (ᾰ : α) => R) (fun (ᾰ : α) => M) (fun (i : α) => SMulZeroClass.toHasSmul.{u3, u2} R M _inst_3 (SMulWithZero.toSmulZeroClass.{u3, u2} R M _inst_2 _inst_3 _inst_4))) f f'))
-but is expected to have type
-  forall {α : Type.{u3}} {M : Type.{u1}} {R : Type.{u2}} [_inst_1 : TopologicalSpace.{u3} α] [_inst_2 : Zero.{u2} R] [_inst_3 : Zero.{u1} M] [_inst_4 : SMulWithZero.{u2, u1} R M _inst_2 _inst_3] {f : α -> R} {f' : α -> M}, (HasCompactSupport.{u3, u2} α R _inst_1 _inst_2 f) -> (HasCompactSupport.{u3, u1} α M _inst_1 _inst_3 (HSMul.hSMul.{max u3 u2, max u3 u1, max u3 u1} (α -> R) (α -> M) (α -> M) (instHSMul.{max u3 u2, max u3 u1} (α -> R) (α -> M) (Pi.smul'.{u3, u2, u1} α (fun (a._@.Mathlib.Topology.Support._hyg.2290 : α) => R) (fun (a._@.Mathlib.Topology.Support._hyg.2293 : α) => M) (fun (i : α) => SMulZeroClass.toSMul.{u2, u1} R M _inst_3 (SMulWithZero.toSMulZeroClass.{u2, u1} R M _inst_2 _inst_3 _inst_4)))) f f'))
-Case conversion may be inaccurate. Consider using '#align has_compact_support.smul_right HasCompactSupport.smul_rightₓ'. -/
 theorem HasCompactSupport.smul_right (hf : HasCompactSupport f) : HasCompactSupport (f • f') :=
   by
   rw [hasCompactSupport_iff_eventuallyEq] at hf⊢
   refine' hf.mono fun x hx => by simp_rw [Pi.smul_apply', hx, Pi.zero_apply, zero_smul]
 #align has_compact_support.smul_right HasCompactSupport.smul_right
 
-/- warning: has_compact_support.smul_left' -> HasCompactSupport.smul_left' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} {R : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_2 : Zero.{u3} R] [_inst_3 : Zero.{u2} M] [_inst_4 : SMulWithZero.{u3, u2} R M _inst_2 _inst_3] {f : α -> R} {f' : α -> M}, (HasCompactSupport.{u1, u2} α M _inst_1 _inst_3 f') -> (HasCompactSupport.{u1, u2} α M _inst_1 _inst_3 (SMul.smul.{max u1 u3, max u1 u2} (α -> R) (α -> M) (Pi.smul'.{u1, u3, u2} α (fun (ᾰ : α) => R) (fun (ᾰ : α) => M) (fun (i : α) => SMulZeroClass.toHasSmul.{u3, u2} R M _inst_3 (SMulWithZero.toSmulZeroClass.{u3, u2} R M _inst_2 _inst_3 _inst_4))) f f'))
-but is expected to have type
-  forall {α : Type.{u3}} {M : Type.{u2}} {R : Type.{u1}} [_inst_1 : TopologicalSpace.{u3} α] [_inst_2 : Zero.{u1} R] [_inst_3 : Zero.{u2} M] [_inst_4 : SMulWithZero.{u1, u2} R M _inst_2 _inst_3] {f : α -> R} {f' : α -> M}, (HasCompactSupport.{u3, u2} α M _inst_1 _inst_3 f') -> (HasCompactSupport.{u3, u2} α M _inst_1 _inst_3 (HSMul.hSMul.{max u3 u1, max u3 u2, max u3 u2} (α -> R) (α -> M) (α -> M) (instHSMul.{max u3 u1, max u3 u2} (α -> R) (α -> M) (Pi.smul'.{u3, u1, u2} α (fun (a._@.Mathlib.Topology.Support._hyg.2383 : α) => R) (fun (a._@.Mathlib.Topology.Support._hyg.2386 : α) => M) (fun (i : α) => SMulZeroClass.toSMul.{u1, u2} R M _inst_3 (SMulWithZero.toSMulZeroClass.{u1, u2} R M _inst_2 _inst_3 _inst_4)))) f f'))
-Case conversion may be inaccurate. Consider using '#align has_compact_support.smul_left' HasCompactSupport.smul_left'ₓ'. -/
 theorem HasCompactSupport.smul_left' (hf : HasCompactSupport f') : HasCompactSupport (f • f') :=
   by
   rw [hasCompactSupport_iff_eventuallyEq] at hf⊢
@@ -449,24 +317,12 @@ variable [TopologicalSpace α] [MulZeroClass β]
 
 variable {f f' : α → β} {x : α}
 
-/- warning: has_compact_support.mul_right -> HasCompactSupport.mul_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_2 : MulZeroClass.{u2} β] {f : α -> β} {f' : α -> β}, (HasCompactSupport.{u1, u2} α β _inst_1 (MulZeroClass.toHasZero.{u2} β _inst_2) f) -> (HasCompactSupport.{u1, u2} α β _inst_1 (MulZeroClass.toHasZero.{u2} β _inst_2) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_2))) f f'))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_2 : MulZeroClass.{u1} β] {f : α -> β} {f' : α -> β}, (HasCompactSupport.{u2, u1} α β _inst_1 (MulZeroClass.toZero.{u1} β _inst_2) f) -> (HasCompactSupport.{u2, u1} α β _inst_1 (MulZeroClass.toZero.{u1} β _inst_2) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u1} β _inst_2))) f f'))
-Case conversion may be inaccurate. Consider using '#align has_compact_support.mul_right HasCompactSupport.mul_rightₓ'. -/
 theorem HasCompactSupport.mul_right (hf : HasCompactSupport f) : HasCompactSupport (f * f') :=
   by
   rw [hasCompactSupport_iff_eventuallyEq] at hf⊢
   refine' hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, MulZeroClass.zero_mul]
 #align has_compact_support.mul_right HasCompactSupport.mul_right
 
-/- warning: has_compact_support.mul_left -> HasCompactSupport.mul_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_2 : MulZeroClass.{u2} β] {f : α -> β} {f' : α -> β}, (HasCompactSupport.{u1, u2} α β _inst_1 (MulZeroClass.toHasZero.{u2} β _inst_2) f') -> (HasCompactSupport.{u1, u2} α β _inst_1 (MulZeroClass.toHasZero.{u2} β _inst_2) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_2))) f f'))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_2 : MulZeroClass.{u1} β] {f : α -> β} {f' : α -> β}, (HasCompactSupport.{u2, u1} α β _inst_1 (MulZeroClass.toZero.{u1} β _inst_2) f') -> (HasCompactSupport.{u2, u1} α β _inst_1 (MulZeroClass.toZero.{u1} β _inst_2) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u1} β _inst_2))) f f'))
-Case conversion may be inaccurate. Consider using '#align has_compact_support.mul_left HasCompactSupport.mul_leftₓ'. -/
 theorem HasCompactSupport.mul_left (hf : HasCompactSupport f') : HasCompactSupport (f * f') :=
   by
   rw [hasCompactSupport_iff_eventuallyEq] at hf⊢
@@ -479,9 +335,6 @@ namespace LocallyFinite
 
 variable {ι : Type _} {U : ι → Set X} [TopologicalSpace X] [One R]
 
-/- warning: locally_finite.exists_finset_nhd_mul_support_subset -> LocallyFinite.exists_finset_nhd_mulSupport_subset is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align locally_finite.exists_finset_nhd_mul_support_subset LocallyFinite.exists_finset_nhd_mulSupport_subsetₓ'. -/
 /-- If a family of functions `f` has locally-finite multiplicative support, subordinate to a family
 of open sets, then for any point we can find a neighbourhood on which only finitely-many members of
 `f` are not equal to 1. -/

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

@@ -480,10 +480,7 @@ namespace LocallyFinite
 variable {ι : Type _} {U : ι → Set X} [TopologicalSpace X] [One R]
 
 /- warning: locally_finite.exists_finset_nhd_mul_support_subset -> LocallyFinite.exists_finset_nhd_mulSupport_subset is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {R : Type.{u2}} {ι : Type.{u3}} {U : ι -> (Set.{u1} X)} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : One.{u2} R] {f : ι -> X -> R}, (LocallyFinite.{u3, u1} ι X _inst_1 (fun (i : ι) => Function.mulSupport.{u1, u2} X R _inst_2 (f i))) -> (forall (i : ι), HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) (mulTSupport.{u1, u2} X R _inst_2 _inst_1 (f i)) (U i)) -> (forall (i : ι), IsOpen.{u1} X _inst_1 (U i)) -> (forall (x : X), Exists.{succ u3} (Finset.{u3} ι) (fun (is : Finset.{u3} ι) => Exists.{succ u1} (Set.{u1} X) (fun {n : Set.{u1} X} => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} X) (Filter.{u1} X) (Filter.hasMem.{u1} X) n (nhds.{u1} X _inst_1 x)) (fun (hn₁ : Membership.Mem.{u1, u1} (Set.{u1} X) (Filter.{u1} X) (Filter.hasMem.{u1} X) n (nhds.{u1} X _inst_1 x)) => Exists.{0} (HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) n (Set.iInter.{u1, succ u3} X ι (fun (i : ι) => Set.iInter.{u1, 0} X (Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i is) (fun (H : Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i is) => U i)))) (fun (hn₂ : HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) n (Set.iInter.{u1, succ u3} X ι (fun (i : ι) => Set.iInter.{u1, 0} X (Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i is) (fun (H : Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i is) => U i)))) => forall (z : X), (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) z n) -> (HasSubset.Subset.{u3} (Set.{u3} ι) (Set.hasSubset.{u3} ι) (Function.mulSupport.{u3, u2} ι R _inst_2 (fun (i : ι) => f i z)) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Finset.{u3} ι) (Set.{u3} ι) (HasLiftT.mk.{succ u3, succ u3} (Finset.{u3} ι) (Set.{u3} ι) (CoeTCₓ.coe.{succ u3, succ u3} (Finset.{u3} ι) (Set.{u3} ι) (Finset.Set.hasCoeT.{u3} ι))) is)))))))
-but is expected to have type
-  forall {X : Type.{u2}} {R : Type.{u1}} {ι : Type.{u3}} {U : ι -> (Set.{u2} X)} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : One.{u1} R] {f : ι -> X -> R}, (LocallyFinite.{u3, u2} ι X _inst_1 (fun (i : ι) => Function.mulSupport.{u2, u1} X R _inst_2 (f i))) -> (forall (i : ι), HasSubset.Subset.{u2} (Set.{u2} X) (Set.instHasSubsetSet.{u2} X) (mulTSupport.{u2, u1} X R _inst_2 _inst_1 (f i)) (U i)) -> (forall (i : ι), IsOpen.{u2} X _inst_1 (U i)) -> (forall (x : X), Exists.{succ u3} (Finset.{u3} ι) (fun (is : Finset.{u3} ι) => Exists.{succ u2} (Set.{u2} X) (fun (n : Set.{u2} X) => And (Membership.mem.{u2, u2} (Set.{u2} X) (Filter.{u2} X) (instMembershipSetFilter.{u2} X) n (nhds.{u2} X _inst_1 x)) (And (HasSubset.Subset.{u2} (Set.{u2} X) (Set.instHasSubsetSet.{u2} X) n (Set.iInter.{u2, succ u3} X ι (fun (i : ι) => Set.iInter.{u2, 0} X (Membership.mem.{u3, u3} ι (Finset.{u3} ι) (Finset.instMembershipFinset.{u3} ι) i is) (fun (h._@.Mathlib.Topology.Support._hyg.2794 : Membership.mem.{u3, u3} ι (Finset.{u3} ι) (Finset.instMembershipFinset.{u3} ι) i is) => U i)))) (forall (z : X), (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) z n) -> (HasSubset.Subset.{u3} (Set.{u3} ι) (Set.instHasSubsetSet.{u3} ι) (Function.mulSupport.{u3, u1} ι R _inst_2 (fun (i : ι) => f i z)) (Finset.toSet.{u3} ι is)))))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align locally_finite.exists_finset_nhd_mul_support_subset LocallyFinite.exists_finset_nhd_mulSupport_subsetₓ'. -/
 /-- If a family of functions `f` has locally-finite multiplicative support, subordinate to a family
 of open sets, then for any point we can find a neighbourhood on which only finitely-many members of

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

@@ -172,7 +172,7 @@ variable {g : β → γ} {f : α → β} {f₂ : α → γ} {m : β → γ → 
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : One.{u2} β] {f : α -> β} {x : α}, Iff (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (mulTSupport.{u1, u2} α β _inst_3 _inst_1 f))) (Filter.EventuallyEq.{u1, u2} α β (nhds.{u1} α _inst_1 x) f (OfNat.ofNat.{max u1 u2} (α -> β) 1 (OfNat.mk.{max u1 u2} (α -> β) 1 (One.one.{max u1 u2} (α -> β) (Pi.instOne.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_3))))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_3 : One.{u1} β] {f : α -> β} {x : α}, Iff (Not (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) x (mulTSupport.{u2, u1} α β _inst_3 _inst_1 f))) (Filter.EventuallyEq.{u2, u1} α β (nhds.{u2} α _inst_1 x) f (OfNat.ofNat.{max u2 u1} (α -> β) 1 (One.toOfNat1.{max u2 u1} (α -> β) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19133 : α) => β) (fun (i : α) => _inst_3)))))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_3 : One.{u1} β] {f : α -> β} {x : α}, Iff (Not (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) x (mulTSupport.{u2, u1} α β _inst_3 _inst_1 f))) (Filter.EventuallyEq.{u2, u1} α β (nhds.{u2} α _inst_1 x) f (OfNat.ofNat.{max u2 u1} (α -> β) 1 (One.toOfNat1.{max u2 u1} (α -> β) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19136 : α) => β) (fun (i : α) => _inst_3)))))
 Case conversion may be inaccurate. Consider using '#align not_mem_mul_tsupport_iff_eventually_eq not_mem_mulTSupport_iff_eventuallyEqₓ'. -/
 @[to_additive]
 theorem not_mem_mulTSupport_iff_eventuallyEq : x ∉ mulTSupport f ↔ f =ᶠ[𝓝 x] 1 := by
@@ -261,7 +261,7 @@ theorem HasCompactMulSupport.isCompact (hf : HasCompactMulSupport f) : IsCompact
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : One.{u2} β] {f : α -> β}, Iff (HasCompactMulSupport.{u1, u2} α β _inst_1 _inst_3 f) (Filter.EventuallyEq.{u1, u2} α β (Filter.coclosedCompact.{u1} α _inst_1) f (OfNat.ofNat.{max u1 u2} (α -> β) 1 (OfNat.mk.{max u1 u2} (α -> β) 1 (One.one.{max u1 u2} (α -> β) (Pi.instOne.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_3))))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_3 : One.{u1} β] {f : α -> β}, Iff (HasCompactMulSupport.{u2, u1} α β _inst_1 _inst_3 f) (Filter.EventuallyEq.{u2, u1} α β (Filter.coclosedCompact.{u2} α _inst_1) f (OfNat.ofNat.{max u2 u1} (α -> β) 1 (One.toOfNat1.{max u2 u1} (α -> β) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19133 : α) => β) (fun (i : α) => _inst_3)))))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_3 : One.{u1} β] {f : α -> β}, Iff (HasCompactMulSupport.{u2, u1} α β _inst_1 _inst_3 f) (Filter.EventuallyEq.{u2, u1} α β (Filter.coclosedCompact.{u2} α _inst_1) f (OfNat.ofNat.{max u2 u1} (α -> β) 1 (One.toOfNat1.{max u2 u1} (α -> β) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19136 : α) => β) (fun (i : α) => _inst_3)))))
 Case conversion may be inaccurate. Consider using '#align has_compact_mul_support_iff_eventually_eq hasCompactMulSupport_iff_eventuallyEqₓ'. -/
 @[to_additive]
 theorem hasCompactMulSupport_iff_eventuallyEq :

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

@@ -481,9 +481,9 @@ variable {ι : Type _} {U : ι → Set X} [TopologicalSpace X] [One R]
 
 /- warning: locally_finite.exists_finset_nhd_mul_support_subset -> LocallyFinite.exists_finset_nhd_mulSupport_subset is a dubious translation:
 lean 3 declaration is
-  forall {X : Type.{u1}} {R : Type.{u2}} {ι : Type.{u3}} {U : ι -> (Set.{u1} X)} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : One.{u2} R] {f : ι -> X -> R}, (LocallyFinite.{u3, u1} ι X _inst_1 (fun (i : ι) => Function.mulSupport.{u1, u2} X R _inst_2 (f i))) -> (forall (i : ι), HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) (mulTSupport.{u1, u2} X R _inst_2 _inst_1 (f i)) (U i)) -> (forall (i : ι), IsOpen.{u1} X _inst_1 (U i)) -> (forall (x : X), Exists.{succ u3} (Finset.{u3} ι) (fun (is : Finset.{u3} ι) => Exists.{succ u1} (Set.{u1} X) (fun {n : Set.{u1} X} => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} X) (Filter.{u1} X) (Filter.hasMem.{u1} X) n (nhds.{u1} X _inst_1 x)) (fun (hn₁ : Membership.Mem.{u1, u1} (Set.{u1} X) (Filter.{u1} X) (Filter.hasMem.{u1} X) n (nhds.{u1} X _inst_1 x)) => Exists.{0} (HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) n (Set.interᵢ.{u1, succ u3} X ι (fun (i : ι) => Set.interᵢ.{u1, 0} X (Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i is) (fun (H : Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i is) => U i)))) (fun (hn₂ : HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) n (Set.interᵢ.{u1, succ u3} X ι (fun (i : ι) => Set.interᵢ.{u1, 0} X (Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i is) (fun (H : Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i is) => U i)))) => forall (z : X), (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) z n) -> (HasSubset.Subset.{u3} (Set.{u3} ι) (Set.hasSubset.{u3} ι) (Function.mulSupport.{u3, u2} ι R _inst_2 (fun (i : ι) => f i z)) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Finset.{u3} ι) (Set.{u3} ι) (HasLiftT.mk.{succ u3, succ u3} (Finset.{u3} ι) (Set.{u3} ι) (CoeTCₓ.coe.{succ u3, succ u3} (Finset.{u3} ι) (Set.{u3} ι) (Finset.Set.hasCoeT.{u3} ι))) is)))))))
+  forall {X : Type.{u1}} {R : Type.{u2}} {ι : Type.{u3}} {U : ι -> (Set.{u1} X)} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : One.{u2} R] {f : ι -> X -> R}, (LocallyFinite.{u3, u1} ι X _inst_1 (fun (i : ι) => Function.mulSupport.{u1, u2} X R _inst_2 (f i))) -> (forall (i : ι), HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) (mulTSupport.{u1, u2} X R _inst_2 _inst_1 (f i)) (U i)) -> (forall (i : ι), IsOpen.{u1} X _inst_1 (U i)) -> (forall (x : X), Exists.{succ u3} (Finset.{u3} ι) (fun (is : Finset.{u3} ι) => Exists.{succ u1} (Set.{u1} X) (fun {n : Set.{u1} X} => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} X) (Filter.{u1} X) (Filter.hasMem.{u1} X) n (nhds.{u1} X _inst_1 x)) (fun (hn₁ : Membership.Mem.{u1, u1} (Set.{u1} X) (Filter.{u1} X) (Filter.hasMem.{u1} X) n (nhds.{u1} X _inst_1 x)) => Exists.{0} (HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) n (Set.iInter.{u1, succ u3} X ι (fun (i : ι) => Set.iInter.{u1, 0} X (Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i is) (fun (H : Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i is) => U i)))) (fun (hn₂ : HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) n (Set.iInter.{u1, succ u3} X ι (fun (i : ι) => Set.iInter.{u1, 0} X (Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i is) (fun (H : Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i is) => U i)))) => forall (z : X), (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) z n) -> (HasSubset.Subset.{u3} (Set.{u3} ι) (Set.hasSubset.{u3} ι) (Function.mulSupport.{u3, u2} ι R _inst_2 (fun (i : ι) => f i z)) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Finset.{u3} ι) (Set.{u3} ι) (HasLiftT.mk.{succ u3, succ u3} (Finset.{u3} ι) (Set.{u3} ι) (CoeTCₓ.coe.{succ u3, succ u3} (Finset.{u3} ι) (Set.{u3} ι) (Finset.Set.hasCoeT.{u3} ι))) is)))))))
 but is expected to have type
-  forall {X : Type.{u2}} {R : Type.{u1}} {ι : Type.{u3}} {U : ι -> (Set.{u2} X)} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : One.{u1} R] {f : ι -> X -> R}, (LocallyFinite.{u3, u2} ι X _inst_1 (fun (i : ι) => Function.mulSupport.{u2, u1} X R _inst_2 (f i))) -> (forall (i : ι), HasSubset.Subset.{u2} (Set.{u2} X) (Set.instHasSubsetSet.{u2} X) (mulTSupport.{u2, u1} X R _inst_2 _inst_1 (f i)) (U i)) -> (forall (i : ι), IsOpen.{u2} X _inst_1 (U i)) -> (forall (x : X), Exists.{succ u3} (Finset.{u3} ι) (fun (is : Finset.{u3} ι) => Exists.{succ u2} (Set.{u2} X) (fun (n : Set.{u2} X) => And (Membership.mem.{u2, u2} (Set.{u2} X) (Filter.{u2} X) (instMembershipSetFilter.{u2} X) n (nhds.{u2} X _inst_1 x)) (And (HasSubset.Subset.{u2} (Set.{u2} X) (Set.instHasSubsetSet.{u2} X) n (Set.interᵢ.{u2, succ u3} X ι (fun (i : ι) => Set.interᵢ.{u2, 0} X (Membership.mem.{u3, u3} ι (Finset.{u3} ι) (Finset.instMembershipFinset.{u3} ι) i is) (fun (h._@.Mathlib.Topology.Support._hyg.2794 : Membership.mem.{u3, u3} ι (Finset.{u3} ι) (Finset.instMembershipFinset.{u3} ι) i is) => U i)))) (forall (z : X), (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) z n) -> (HasSubset.Subset.{u3} (Set.{u3} ι) (Set.instHasSubsetSet.{u3} ι) (Function.mulSupport.{u3, u1} ι R _inst_2 (fun (i : ι) => f i z)) (Finset.toSet.{u3} ι is)))))))
+  forall {X : Type.{u2}} {R : Type.{u1}} {ι : Type.{u3}} {U : ι -> (Set.{u2} X)} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : One.{u1} R] {f : ι -> X -> R}, (LocallyFinite.{u3, u2} ι X _inst_1 (fun (i : ι) => Function.mulSupport.{u2, u1} X R _inst_2 (f i))) -> (forall (i : ι), HasSubset.Subset.{u2} (Set.{u2} X) (Set.instHasSubsetSet.{u2} X) (mulTSupport.{u2, u1} X R _inst_2 _inst_1 (f i)) (U i)) -> (forall (i : ι), IsOpen.{u2} X _inst_1 (U i)) -> (forall (x : X), Exists.{succ u3} (Finset.{u3} ι) (fun (is : Finset.{u3} ι) => Exists.{succ u2} (Set.{u2} X) (fun (n : Set.{u2} X) => And (Membership.mem.{u2, u2} (Set.{u2} X) (Filter.{u2} X) (instMembershipSetFilter.{u2} X) n (nhds.{u2} X _inst_1 x)) (And (HasSubset.Subset.{u2} (Set.{u2} X) (Set.instHasSubsetSet.{u2} X) n (Set.iInter.{u2, succ u3} X ι (fun (i : ι) => Set.iInter.{u2, 0} X (Membership.mem.{u3, u3} ι (Finset.{u3} ι) (Finset.instMembershipFinset.{u3} ι) i is) (fun (h._@.Mathlib.Topology.Support._hyg.2794 : Membership.mem.{u3, u3} ι (Finset.{u3} ι) (Finset.instMembershipFinset.{u3} ι) i is) => U i)))) (forall (z : X), (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) z n) -> (HasSubset.Subset.{u3} (Set.{u3} ι) (Set.instHasSubsetSet.{u3} ι) (Function.mulSupport.{u3, u1} ι R _inst_2 (fun (i : ι) => f i z)) (Finset.toSet.{u3} ι is)))))))
 Case conversion may be inaccurate. Consider using '#align locally_finite.exists_finset_nhd_mul_support_subset LocallyFinite.exists_finset_nhd_mulSupport_subsetₓ'. -/
 /-- If a family of functions `f` has locally-finite multiplicative support, subordinate to a family
 of open sets, then for any point we can find a neighbourhood on which only finitely-many members of

mathlib commit https://github.com/leanprover-community/mathlib/commit/36b8aa61ea7c05727161f96a0532897bd72aedab

@@ -172,7 +172,7 @@ variable {g : β → γ} {f : α → β} {f₂ : α → γ} {m : β → γ → 
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : One.{u2} β] {f : α -> β} {x : α}, Iff (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (mulTSupport.{u1, u2} α β _inst_3 _inst_1 f))) (Filter.EventuallyEq.{u1, u2} α β (nhds.{u1} α _inst_1 x) f (OfNat.ofNat.{max u1 u2} (α -> β) 1 (OfNat.mk.{max u1 u2} (α -> β) 1 (One.one.{max u1 u2} (α -> β) (Pi.instOne.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_3))))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_3 : One.{u1} β] {f : α -> β} {x : α}, Iff (Not (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) x (mulTSupport.{u2, u1} α β _inst_3 _inst_1 f))) (Filter.EventuallyEq.{u2, u1} α β (nhds.{u2} α _inst_1 x) f (OfNat.ofNat.{max u2 u1} (α -> β) 1 (One.toOfNat1.{max u2 u1} (α -> β) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19139 : α) => β) (fun (i : α) => _inst_3)))))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_3 : One.{u1} β] {f : α -> β} {x : α}, Iff (Not (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) x (mulTSupport.{u2, u1} α β _inst_3 _inst_1 f))) (Filter.EventuallyEq.{u2, u1} α β (nhds.{u2} α _inst_1 x) f (OfNat.ofNat.{max u2 u1} (α -> β) 1 (One.toOfNat1.{max u2 u1} (α -> β) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19133 : α) => β) (fun (i : α) => _inst_3)))))
 Case conversion may be inaccurate. Consider using '#align not_mem_mul_tsupport_iff_eventually_eq not_mem_mulTSupport_iff_eventuallyEqₓ'. -/
 @[to_additive]
 theorem not_mem_mulTSupport_iff_eventuallyEq : x ∉ mulTSupport f ↔ f =ᶠ[𝓝 x] 1 := by
@@ -261,7 +261,7 @@ theorem HasCompactMulSupport.isCompact (hf : HasCompactMulSupport f) : IsCompact
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : One.{u2} β] {f : α -> β}, Iff (HasCompactMulSupport.{u1, u2} α β _inst_1 _inst_3 f) (Filter.EventuallyEq.{u1, u2} α β (Filter.coclosedCompact.{u1} α _inst_1) f (OfNat.ofNat.{max u1 u2} (α -> β) 1 (OfNat.mk.{max u1 u2} (α -> β) 1 (One.one.{max u1 u2} (α -> β) (Pi.instOne.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_3))))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_3 : One.{u1} β] {f : α -> β}, Iff (HasCompactMulSupport.{u2, u1} α β _inst_1 _inst_3 f) (Filter.EventuallyEq.{u2, u1} α β (Filter.coclosedCompact.{u2} α _inst_1) f (OfNat.ofNat.{max u2 u1} (α -> β) 1 (One.toOfNat1.{max u2 u1} (α -> β) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19139 : α) => β) (fun (i : α) => _inst_3)))))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_3 : One.{u1} β] {f : α -> β}, Iff (HasCompactMulSupport.{u2, u1} α β _inst_1 _inst_3 f) (Filter.EventuallyEq.{u2, u1} α β (Filter.coclosedCompact.{u2} α _inst_1) f (OfNat.ofNat.{max u2 u1} (α -> β) 1 (One.toOfNat1.{max u2 u1} (α -> β) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19133 : α) => β) (fun (i : α) => _inst_3)))))
 Case conversion may be inaccurate. Consider using '#align has_compact_mul_support_iff_eventually_eq hasCompactMulSupport_iff_eventuallyEqₓ'. -/
 @[to_additive]
 theorem hasCompactMulSupport_iff_eventuallyEq :
@@ -401,7 +401,7 @@ variable {f : α → R} {f' : α → M} {x : α}
 lean 3 declaration is
   forall {α : Type.{u1}} {M : Type.{u2}} {R : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_2 : MonoidWithZero.{u3} R] [_inst_3 : AddMonoid.{u2} M] [_inst_4 : DistribMulAction.{u3, u2} R M (MonoidWithZero.toMonoid.{u3} R _inst_2) _inst_3] {f : α -> R} {f' : α -> M}, (HasCompactSupport.{u1, u2} α M _inst_1 (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M _inst_3)) f') -> (HasCompactSupport.{u1, u2} α M _inst_1 (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M _inst_3)) (SMul.smul.{max u1 u3, max u1 u2} (α -> R) (α -> M) (Pi.smul'.{u1, u3, u2} α (fun (ᾰ : α) => R) (fun (ᾰ : α) => M) (fun (i : α) => SMulZeroClass.toHasSmul.{u3, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M _inst_3)) (DistribSMul.toSmulZeroClass.{u3, u2} R M (AddMonoid.toAddZeroClass.{u2} M _inst_3) (DistribMulAction.toDistribSMul.{u3, u2} R M (MonoidWithZero.toMonoid.{u3} R _inst_2) _inst_3 _inst_4)))) f f'))
 but is expected to have type
-  forall {α : Type.{u3}} {M : Type.{u2}} {R : Type.{u1}} [_inst_1 : TopologicalSpace.{u3} α] [_inst_2 : MonoidWithZero.{u1} R] [_inst_3 : AddMonoid.{u2} M] [_inst_4 : DistribMulAction.{u1, u2} R M (MonoidWithZero.toMonoid.{u1} R _inst_2) _inst_3] {f : α -> R} {f' : α -> M}, (HasCompactSupport.{u3, u2} α M _inst_1 (AddMonoid.toZero.{u2} M _inst_3) f') -> (HasCompactSupport.{u3, u2} α M _inst_1 (AddMonoid.toZero.{u2} M _inst_3) (HSMul.hSMul.{max u3 u1, max u3 u2, max u3 u2} (α -> R) (α -> M) (α -> M) (instHSMul.{max u3 u1, max u3 u2} (α -> R) (α -> M) (Pi.smul'.{u3, u1, u2} α (fun (a._@.Mathlib.Topology.Support._hyg.2143 : α) => R) (fun (a._@.Mathlib.Topology.Support._hyg.2146 : α) => M) (fun (i : α) => SMulZeroClass.toSMul.{u1, u2} R M (AddMonoid.toZero.{u2} M _inst_3) (DistribSMul.toSMulZeroClass.{u1, u2} R M (AddMonoid.toAddZeroClass.{u2} M _inst_3) (DistribMulAction.toDistribSMul.{u1, u2} R M (MonoidWithZero.toMonoid.{u1} R _inst_2) _inst_3 _inst_4))))) f f'))
+  forall {α : Type.{u3}} {M : Type.{u2}} {R : Type.{u1}} [_inst_1 : TopologicalSpace.{u3} α] [_inst_2 : MonoidWithZero.{u1} R] [_inst_3 : AddMonoid.{u2} M] [_inst_4 : DistribMulAction.{u1, u2} R M (MonoidWithZero.toMonoid.{u1} R _inst_2) _inst_3] {f : α -> R} {f' : α -> M}, (HasCompactSupport.{u3, u2} α M _inst_1 (AddMonoid.toZero.{u2} M _inst_3) f') -> (HasCompactSupport.{u3, u2} α M _inst_1 (AddMonoid.toZero.{u2} M _inst_3) (HSMul.hSMul.{max u3 u1, max u3 u2, max u3 u2} (α -> R) (α -> M) (α -> M) (instHSMul.{max u3 u1, max u3 u2} (α -> R) (α -> M) (Pi.smul'.{u3, u1, u2} α (fun (a._@.Mathlib.Topology.Support._hyg.2135 : α) => R) (fun (a._@.Mathlib.Topology.Support._hyg.2138 : α) => M) (fun (i : α) => SMulZeroClass.toSMul.{u1, u2} R M (AddMonoid.toZero.{u2} M _inst_3) (DistribSMul.toSMulZeroClass.{u1, u2} R M (AddMonoid.toAddZeroClass.{u2} M _inst_3) (DistribMulAction.toDistribSMul.{u1, u2} R M (MonoidWithZero.toMonoid.{u1} R _inst_2) _inst_3 _inst_4))))) f f'))
 Case conversion may be inaccurate. Consider using '#align has_compact_support.smul_left HasCompactSupport.smul_leftₓ'. -/
 theorem HasCompactSupport.smul_left (hf : HasCompactSupport f') : HasCompactSupport (f • f') :=
   by
@@ -421,7 +421,7 @@ variable {f : α → R} {f' : α → M} {x : α}
 lean 3 declaration is
   forall {α : Type.{u1}} {M : Type.{u2}} {R : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_2 : Zero.{u3} R] [_inst_3 : Zero.{u2} M] [_inst_4 : SMulWithZero.{u3, u2} R M _inst_2 _inst_3] {f : α -> R} {f' : α -> M}, (HasCompactSupport.{u1, u3} α R _inst_1 _inst_2 f) -> (HasCompactSupport.{u1, u2} α M _inst_1 _inst_3 (SMul.smul.{max u1 u3, max u1 u2} (α -> R) (α -> M) (Pi.smul'.{u1, u3, u2} α (fun (ᾰ : α) => R) (fun (ᾰ : α) => M) (fun (i : α) => SMulZeroClass.toHasSmul.{u3, u2} R M _inst_3 (SMulWithZero.toSmulZeroClass.{u3, u2} R M _inst_2 _inst_3 _inst_4))) f f'))
 but is expected to have type
-  forall {α : Type.{u3}} {M : Type.{u1}} {R : Type.{u2}} [_inst_1 : TopologicalSpace.{u3} α] [_inst_2 : Zero.{u2} R] [_inst_3 : Zero.{u1} M] [_inst_4 : SMulWithZero.{u2, u1} R M _inst_2 _inst_3] {f : α -> R} {f' : α -> M}, (HasCompactSupport.{u3, u2} α R _inst_1 _inst_2 f) -> (HasCompactSupport.{u3, u1} α M _inst_1 _inst_3 (HSMul.hSMul.{max u3 u2, max u3 u1, max u3 u1} (α -> R) (α -> M) (α -> M) (instHSMul.{max u3 u2, max u3 u1} (α -> R) (α -> M) (Pi.smul'.{u3, u2, u1} α (fun (a._@.Mathlib.Topology.Support._hyg.2300 : α) => R) (fun (a._@.Mathlib.Topology.Support._hyg.2303 : α) => M) (fun (i : α) => SMulZeroClass.toSMul.{u2, u1} R M _inst_3 (SMulWithZero.toSMulZeroClass.{u2, u1} R M _inst_2 _inst_3 _inst_4)))) f f'))
+  forall {α : Type.{u3}} {M : Type.{u1}} {R : Type.{u2}} [_inst_1 : TopologicalSpace.{u3} α] [_inst_2 : Zero.{u2} R] [_inst_3 : Zero.{u1} M] [_inst_4 : SMulWithZero.{u2, u1} R M _inst_2 _inst_3] {f : α -> R} {f' : α -> M}, (HasCompactSupport.{u3, u2} α R _inst_1 _inst_2 f) -> (HasCompactSupport.{u3, u1} α M _inst_1 _inst_3 (HSMul.hSMul.{max u3 u2, max u3 u1, max u3 u1} (α -> R) (α -> M) (α -> M) (instHSMul.{max u3 u2, max u3 u1} (α -> R) (α -> M) (Pi.smul'.{u3, u2, u1} α (fun (a._@.Mathlib.Topology.Support._hyg.2290 : α) => R) (fun (a._@.Mathlib.Topology.Support._hyg.2293 : α) => M) (fun (i : α) => SMulZeroClass.toSMul.{u2, u1} R M _inst_3 (SMulWithZero.toSMulZeroClass.{u2, u1} R M _inst_2 _inst_3 _inst_4)))) f f'))
 Case conversion may be inaccurate. Consider using '#align has_compact_support.smul_right HasCompactSupport.smul_rightₓ'. -/
 theorem HasCompactSupport.smul_right (hf : HasCompactSupport f) : HasCompactSupport (f • f') :=
   by
@@ -433,7 +433,7 @@ theorem HasCompactSupport.smul_right (hf : HasCompactSupport f) : HasCompactSupp
 lean 3 declaration is
   forall {α : Type.{u1}} {M : Type.{u2}} {R : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_2 : Zero.{u3} R] [_inst_3 : Zero.{u2} M] [_inst_4 : SMulWithZero.{u3, u2} R M _inst_2 _inst_3] {f : α -> R} {f' : α -> M}, (HasCompactSupport.{u1, u2} α M _inst_1 _inst_3 f') -> (HasCompactSupport.{u1, u2} α M _inst_1 _inst_3 (SMul.smul.{max u1 u3, max u1 u2} (α -> R) (α -> M) (Pi.smul'.{u1, u3, u2} α (fun (ᾰ : α) => R) (fun (ᾰ : α) => M) (fun (i : α) => SMulZeroClass.toHasSmul.{u3, u2} R M _inst_3 (SMulWithZero.toSmulZeroClass.{u3, u2} R M _inst_2 _inst_3 _inst_4))) f f'))
 but is expected to have type
-  forall {α : Type.{u3}} {M : Type.{u2}} {R : Type.{u1}} [_inst_1 : TopologicalSpace.{u3} α] [_inst_2 : Zero.{u1} R] [_inst_3 : Zero.{u2} M] [_inst_4 : SMulWithZero.{u1, u2} R M _inst_2 _inst_3] {f : α -> R} {f' : α -> M}, (HasCompactSupport.{u3, u2} α M _inst_1 _inst_3 f') -> (HasCompactSupport.{u3, u2} α M _inst_1 _inst_3 (HSMul.hSMul.{max u3 u1, max u3 u2, max u3 u2} (α -> R) (α -> M) (α -> M) (instHSMul.{max u3 u1, max u3 u2} (α -> R) (α -> M) (Pi.smul'.{u3, u1, u2} α (fun (a._@.Mathlib.Topology.Support._hyg.2395 : α) => R) (fun (a._@.Mathlib.Topology.Support._hyg.2398 : α) => M) (fun (i : α) => SMulZeroClass.toSMul.{u1, u2} R M _inst_3 (SMulWithZero.toSMulZeroClass.{u1, u2} R M _inst_2 _inst_3 _inst_4)))) f f'))
+  forall {α : Type.{u3}} {M : Type.{u2}} {R : Type.{u1}} [_inst_1 : TopologicalSpace.{u3} α] [_inst_2 : Zero.{u1} R] [_inst_3 : Zero.{u2} M] [_inst_4 : SMulWithZero.{u1, u2} R M _inst_2 _inst_3] {f : α -> R} {f' : α -> M}, (HasCompactSupport.{u3, u2} α M _inst_1 _inst_3 f') -> (HasCompactSupport.{u3, u2} α M _inst_1 _inst_3 (HSMul.hSMul.{max u3 u1, max u3 u2, max u3 u2} (α -> R) (α -> M) (α -> M) (instHSMul.{max u3 u1, max u3 u2} (α -> R) (α -> M) (Pi.smul'.{u3, u1, u2} α (fun (a._@.Mathlib.Topology.Support._hyg.2383 : α) => R) (fun (a._@.Mathlib.Topology.Support._hyg.2386 : α) => M) (fun (i : α) => SMulZeroClass.toSMul.{u1, u2} R M _inst_3 (SMulWithZero.toSMulZeroClass.{u1, u2} R M _inst_2 _inst_3 _inst_4)))) f f'))
 Case conversion may be inaccurate. Consider using '#align has_compact_support.smul_left' HasCompactSupport.smul_left'ₓ'. -/
 theorem HasCompactSupport.smul_left' (hf : HasCompactSupport f') : HasCompactSupport (f • f') :=
   by
@@ -483,7 +483,7 @@ variable {ι : Type _} {U : ι → Set X} [TopologicalSpace X] [One R]
 lean 3 declaration is
   forall {X : Type.{u1}} {R : Type.{u2}} {ι : Type.{u3}} {U : ι -> (Set.{u1} X)} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : One.{u2} R] {f : ι -> X -> R}, (LocallyFinite.{u3, u1} ι X _inst_1 (fun (i : ι) => Function.mulSupport.{u1, u2} X R _inst_2 (f i))) -> (forall (i : ι), HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) (mulTSupport.{u1, u2} X R _inst_2 _inst_1 (f i)) (U i)) -> (forall (i : ι), IsOpen.{u1} X _inst_1 (U i)) -> (forall (x : X), Exists.{succ u3} (Finset.{u3} ι) (fun (is : Finset.{u3} ι) => Exists.{succ u1} (Set.{u1} X) (fun {n : Set.{u1} X} => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} X) (Filter.{u1} X) (Filter.hasMem.{u1} X) n (nhds.{u1} X _inst_1 x)) (fun (hn₁ : Membership.Mem.{u1, u1} (Set.{u1} X) (Filter.{u1} X) (Filter.hasMem.{u1} X) n (nhds.{u1} X _inst_1 x)) => Exists.{0} (HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) n (Set.interᵢ.{u1, succ u3} X ι (fun (i : ι) => Set.interᵢ.{u1, 0} X (Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i is) (fun (H : Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i is) => U i)))) (fun (hn₂ : HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) n (Set.interᵢ.{u1, succ u3} X ι (fun (i : ι) => Set.interᵢ.{u1, 0} X (Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i is) (fun (H : Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i is) => U i)))) => forall (z : X), (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) z n) -> (HasSubset.Subset.{u3} (Set.{u3} ι) (Set.hasSubset.{u3} ι) (Function.mulSupport.{u3, u2} ι R _inst_2 (fun (i : ι) => f i z)) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Finset.{u3} ι) (Set.{u3} ι) (HasLiftT.mk.{succ u3, succ u3} (Finset.{u3} ι) (Set.{u3} ι) (CoeTCₓ.coe.{succ u3, succ u3} (Finset.{u3} ι) (Set.{u3} ι) (Finset.Set.hasCoeT.{u3} ι))) is)))))))
 but is expected to have type
-  forall {X : Type.{u2}} {R : Type.{u1}} {ι : Type.{u3}} {U : ι -> (Set.{u2} X)} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : One.{u1} R] {f : ι -> X -> R}, (LocallyFinite.{u3, u2} ι X _inst_1 (fun (i : ι) => Function.mulSupport.{u2, u1} X R _inst_2 (f i))) -> (forall (i : ι), HasSubset.Subset.{u2} (Set.{u2} X) (Set.instHasSubsetSet.{u2} X) (mulTSupport.{u2, u1} X R _inst_2 _inst_1 (f i)) (U i)) -> (forall (i : ι), IsOpen.{u2} X _inst_1 (U i)) -> (forall (x : X), Exists.{succ u3} (Finset.{u3} ι) (fun (is : Finset.{u3} ι) => Exists.{succ u2} (Set.{u2} X) (fun (n : Set.{u2} X) => And (Membership.mem.{u2, u2} (Set.{u2} X) (Filter.{u2} X) (instMembershipSetFilter.{u2} X) n (nhds.{u2} X _inst_1 x)) (And (HasSubset.Subset.{u2} (Set.{u2} X) (Set.instHasSubsetSet.{u2} X) n (Set.interᵢ.{u2, succ u3} X ι (fun (i : ι) => Set.interᵢ.{u2, 0} X (Membership.mem.{u3, u3} ι (Finset.{u3} ι) (Finset.instMembershipFinset.{u3} ι) i is) (fun (h._@.Mathlib.Topology.Support._hyg.2812 : Membership.mem.{u3, u3} ι (Finset.{u3} ι) (Finset.instMembershipFinset.{u3} ι) i is) => U i)))) (forall (z : X), (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) z n) -> (HasSubset.Subset.{u3} (Set.{u3} ι) (Set.instHasSubsetSet.{u3} ι) (Function.mulSupport.{u3, u1} ι R _inst_2 (fun (i : ι) => f i z)) (Finset.toSet.{u3} ι is)))))))
+  forall {X : Type.{u2}} {R : Type.{u1}} {ι : Type.{u3}} {U : ι -> (Set.{u2} X)} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : One.{u1} R] {f : ι -> X -> R}, (LocallyFinite.{u3, u2} ι X _inst_1 (fun (i : ι) => Function.mulSupport.{u2, u1} X R _inst_2 (f i))) -> (forall (i : ι), HasSubset.Subset.{u2} (Set.{u2} X) (Set.instHasSubsetSet.{u2} X) (mulTSupport.{u2, u1} X R _inst_2 _inst_1 (f i)) (U i)) -> (forall (i : ι), IsOpen.{u2} X _inst_1 (U i)) -> (forall (x : X), Exists.{succ u3} (Finset.{u3} ι) (fun (is : Finset.{u3} ι) => Exists.{succ u2} (Set.{u2} X) (fun (n : Set.{u2} X) => And (Membership.mem.{u2, u2} (Set.{u2} X) (Filter.{u2} X) (instMembershipSetFilter.{u2} X) n (nhds.{u2} X _inst_1 x)) (And (HasSubset.Subset.{u2} (Set.{u2} X) (Set.instHasSubsetSet.{u2} X) n (Set.interᵢ.{u2, succ u3} X ι (fun (i : ι) => Set.interᵢ.{u2, 0} X (Membership.mem.{u3, u3} ι (Finset.{u3} ι) (Finset.instMembershipFinset.{u3} ι) i is) (fun (h._@.Mathlib.Topology.Support._hyg.2794 : Membership.mem.{u3, u3} ι (Finset.{u3} ι) (Finset.instMembershipFinset.{u3} ι) i is) => U i)))) (forall (z : X), (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) z n) -> (HasSubset.Subset.{u3} (Set.{u3} ι) (Set.instHasSubsetSet.{u3} ι) (Function.mulSupport.{u3, u1} ι R _inst_2 (fun (i : ι) => f i z)) (Finset.toSet.{u3} ι is)))))))
 Case conversion may be inaccurate. Consider using '#align locally_finite.exists_finset_nhd_mul_support_subset LocallyFinite.exists_finset_nhd_mulSupport_subsetₓ'. -/
 /-- If a family of functions `f` has locally-finite multiplicative support, subordinate to a family
 of open sets, then for any point we can find a neighbourhood on which only finitely-many members of

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

@@ -458,7 +458,7 @@ Case conversion may be inaccurate. Consider using '#align has_compact_support.mu
 theorem HasCompactSupport.mul_right (hf : HasCompactSupport f) : HasCompactSupport (f * f') :=
   by
   rw [hasCompactSupport_iff_eventuallyEq] at hf⊢
-  refine' hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, zero_mul]
+  refine' hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, MulZeroClass.zero_mul]
 #align has_compact_support.mul_right HasCompactSupport.mul_right
 
 /- warning: has_compact_support.mul_left -> HasCompactSupport.mul_left is a dubious translation:
@@ -470,7 +470,7 @@ Case conversion may be inaccurate. Consider using '#align has_compact_support.mu
 theorem HasCompactSupport.mul_left (hf : HasCompactSupport f') : HasCompactSupport (f * f') :=
   by
   rw [hasCompactSupport_iff_eventuallyEq] at hf⊢
-  refine' hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, mul_zero]
+  refine' hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, MulZeroClass.mul_zero]
 #align has_compact_support.mul_left HasCompactSupport.mul_left
 
 end MulZeroClass

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

@@ -222,7 +222,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_3 : One.{u1} β] {f : α -> β} [_inst_6 : T2Space.{u2} α _inst_1], Iff (Exists.{succ u2} (Set.{u2} α) (fun (K : Set.{u2} α) => And (IsCompact.{u2} α _inst_1 K) (forall (x : α), (Not (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) x K)) -> (Eq.{succ u1} β (f x) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β _inst_3)))))) (HasCompactMulSupport.{u2, u1} α β _inst_1 _inst_3 f)
 Case conversion may be inaccurate. Consider using '#align exists_compact_iff_has_compact_mul_support exists_compact_iff_hasCompactMulSupportₓ'. -/
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (x «expr ∉ » K) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (x «expr ∉ » K) -/
 @[to_additive]
 theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
     (∃ K : Set α, IsCompact K ∧ ∀ (x) (_ : x ∉ K), f x = 1) ↔ HasCompactMulSupport f := by
@@ -237,7 +237,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_3 : One.{u1} β] {f : α -> β} [_inst_6 : T2Space.{u2} α _inst_1] {K : Set.{u2} α}, (IsCompact.{u2} α _inst_1 K) -> (forall (x : α), (Not (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) x K)) -> (Eq.{succ u1} β (f x) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β _inst_3)))) -> (HasCompactMulSupport.{u2, u1} α β _inst_1 _inst_3 f)
 Case conversion may be inaccurate. Consider using '#align has_compact_mul_support.intro HasCompactMulSupport.introₓ'. -/
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (x «expr ∉ » K) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (x «expr ∉ » K) -/
 @[to_additive]
 theorem HasCompactMulSupport.intro [T2Space α] {K : Set α} (hK : IsCompact K)
     (hfK : ∀ (x) (_ : x ∉ K), f x = 1) : HasCompactMulSupport f :=

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

Generalize coclosedCompact_eq_cocompact and relativelyCompact.

@@ -198,12 +198,7 @@ theorem isCompact (hf : HasCompactMulSupport f) : IsCompact (mulTSupport f) :=
 @[to_additive]
 theorem _root_.hasCompactMulSupport_iff_eventuallyEq :
     HasCompactMulSupport f ↔ f =ᶠ[coclosedCompact α] 1 :=
-  ⟨fun h => mem_coclosedCompact.mpr
-    ⟨mulTSupport f, isClosed_mulTSupport _, h,
-      fun _ => not_imp_comm.mpr fun hx => subset_mulTSupport f hx⟩,
-    fun h =>
-      let ⟨_C, hC⟩ := mem_coclosed_compact'.mp h
-      IsCompact.of_isClosed_subset hC.2.1 (isClosed_mulTSupport _) (closure_minimal hC.2.2 hC.1)⟩
+  mem_coclosedCompact_iff.symm
 #align has_compact_mul_support_iff_eventually_eq hasCompactMulSupport_iff_eventuallyEq
 #align has_compact_support_iff_eventually_eq hasCompactSupport_iff_eventuallyEq
 

Empty lines were removed by executing the following Python script twice

import os
import re


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

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

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

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

@@ -117,9 +117,7 @@ theorem mulTSupport_mul [TopologicalSpace X] [Monoid α] {f g : X → α} :
 section
 
 variable [TopologicalSpace α] [TopologicalSpace α']
-
 variable [One β] [One γ] [One δ]
-
 variable {g : β → γ} {f : α → β} {f₂ : α → γ} {m : β → γ → δ} {x : α}
 
 @[to_additive]
@@ -142,9 +140,7 @@ end
 /-! ## Functions with compact support -/
 section CompactSupport
 variable [TopologicalSpace α] [TopologicalSpace α']
-
 variable [One β] [One γ] [One δ]
-
 variable {g : β → γ} {f : α → β} {f₂ : α → γ} {m : β → γ → δ} {x : α}
 
 /-- A function `f` *has compact multiplicative support* or is *compactly supported* if the closure
@@ -319,7 +315,6 @@ section CompactSupport2
 section Monoid
 
 variable [TopologicalSpace α] [Monoid β]
-
 variable {f f' : α → β} {x : α}
 
 @[to_additive]
@@ -333,7 +328,6 @@ end Monoid
 section DistribMulAction
 
 variable [TopologicalSpace α] [MonoidWithZero R] [AddMonoid M] [DistribMulAction R M]
-
 variable {f : α → R} {f' : α → M} {x : α}
 
 theorem HasCompactSupport.smul_left (hf : HasCompactSupport f') : HasCompactSupport (f • f') := by
@@ -346,7 +340,6 @@ end DistribMulAction
 section SMulWithZero
 
 variable [TopologicalSpace α] [Zero R] [Zero M] [SMulWithZero R M]
-
 variable {f : α → R} {f' : α → M} {x : α}
 
 theorem HasCompactSupport.smul_right (hf : HasCompactSupport f) : HasCompactSupport (f • f') := by
@@ -364,7 +357,6 @@ end SMulWithZero
 section MulZeroClass
 
 variable [TopologicalSpace α] [MulZeroClass β]
-
 variable {f f' : α → β} {x : α}
 
 theorem HasCompactSupport.mul_right (hf : HasCompactSupport f) : HasCompactSupport (f * f') := by

Classifies by adding issue number #11215 to porting notes claiming "TODO".

@@ -385,7 +385,7 @@ section LocallyFinite
 
 variable {ι : Type*} [TopologicalSpace X]
 
--- Porting note: todo: reformulate for any locally finite family of sets
+-- Porting note (#11215): TODO: reformulate for any locally finite family of sets
 /-- If a family of functions `f` has locally-finite multiplicative support, subordinate to a family
 of open sets, then for any point we can find a neighbourhood on which only finitely-many members of
 `f` are not equal to 1. -/

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

• converts "--porting note" into "-- Porting note";
• converts "porting note" into "Porting note".

@@ -385,7 +385,7 @@ section LocallyFinite
 
 variable {ι : Type*} [TopologicalSpace X]
 
--- porting note: todo: reformulate for any locally finite family of sets
+-- Porting note: todo: reformulate for any locally finite family of sets
 /-- If a family of functions `f` has locally-finite multiplicative support, subordinate to a family
 of open sets, then for any point we can find a neighbourhood on which only finitely-many members of
 `f` are not equal to 1. -/

Co-authored-by: Patrick Massot <patrickmassot@free.fr> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -411,7 +411,8 @@ theorem LocallyFinite.exists_finset_nhd_mulSupport_subset {U : ι → Set X} [On
         rw [inter_assoc] at hz
         exact mem_of_mem_inter_left hz
       replace hz := mem_of_mem_inter_right (mem_of_mem_inter_left hz)
-      simp only [Finset.mem_filter, Finite.mem_toFinset, mem_setOf_eq, mem_iInter, and_imp] at hz
+      simp only [js, Finset.mem_filter, Finite.mem_toFinset, mem_setOf_eq, mem_iInter,
+        and_imp] at hz
       suffices (mulSupport fun i => f i z) ⊆ hnf.toFinset by
         refine' hnf.toFinset.subset_coe_filter_of_subset_forall _ this fun i hi => _
         specialize hz i ⟨z, ⟨hi, hzn⟩⟩

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.

@@ -356,7 +356,7 @@ theorem HasCompactSupport.smul_right (hf : HasCompactSupport f) : HasCompactSupp
 
 theorem HasCompactSupport.smul_left' (hf : HasCompactSupport f') : HasCompactSupport (f • f') := by
   rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
-  refine' hf.mono fun x hx => by simp_rw [Pi.smul_apply', hx, Pi.zero_apply, smul_zero]
+  exact hf.mono fun x hx => by simp_rw [Pi.smul_apply', hx, Pi.zero_apply, smul_zero]
 #align has_compact_support.smul_left' HasCompactSupport.smul_left'
 
 end SMulWithZero
@@ -369,12 +369,12 @@ variable {f f' : α → β} {x : α}
 
 theorem HasCompactSupport.mul_right (hf : HasCompactSupport f) : HasCompactSupport (f * f') := by
   rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
-  refine' hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, zero_mul]
+  exact hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, zero_mul]
 #align has_compact_support.mul_right HasCompactSupport.mul_right
 
 theorem HasCompactSupport.mul_left (hf : HasCompactSupport f') : HasCompactSupport (f * f') := by
   rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
-  refine' hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, mul_zero]
+  exact hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, mul_zero]
 #align has_compact_support.mul_left HasCompactSupport.mul_left
 
 end MulZeroClass

Main API changes

• Define R1Space, a.k.a. preregular space.
• Drop T2OrLocallyCompactRegularSpace.
• Generalize all existing theorems about T2OrLocallyCompactRegularSpace to R1Space.
• Drop the [T2OrLocallyCompactRegularSpace _] assumption if the space is known to be regular for other reason (e.g., because it's a topological group).

New theorems

• Specializes.not_disjoint: if x ⤳ y, then 𝓝 x and 𝓝 y aren't disjoint;
• specializes_iff_not_disjoint, Specializes.inseparable, disjoint_nhds_nhds_iff_not_inseparable, r1Space_iff_inseparable_or_disjoint_nhds: basic API about R1Spaces;
• Inducing.r1Space, R1Space.induced, R1Space.sInf, R1Space.iInf, R1Space.inf, instances for Subtype _, X × Y, and ∀ i, X i: basic instances for R1Space;
• IsCompact.mem_closure_iff_exists_inseparable, IsCompact.closure_eq_biUnion_inseparable: characterizations of the closure of a compact set in a preregular space;
• Inseparable.mem_measurableSet_iff: topologically inseparable points can't be separated by a Borel measurable set;
• IsCompact.closure_subset_measurableSet, IsCompact.measure_closure: in a preregular space, a measurable superset of a compact set includes its closure as well; as a corollary, closure K has the same measure as K.
• exists_mem_nhds_isCompact_mapsTo_of_isCompact_mem_nhds: an auxiliary lemma extracted from a LocallyCompactPair instance;
• IsCompact.isCompact_isClosed_basis_nhds: if x admits a compact neighborhood, then it admits a basis of compact closed neighborhoods; in particular, a weakly locally compact preregular space is a locally compact regular space;
• isCompact_isClosed_basis_nhds: a version of the previous theorem for weakly locally compact spaces;
• exists_mem_nhds_isCompact_isClosed: in a locally compact regular space, each point admits a compact closed neighborhood.

Deprecated theorems

Some theorems about topological groups are true for any (pre)regular space, so we deprecate the special cases.

• exists_isCompact_isClosed_subset_isCompact_nhds_one: use new IsCompact.isCompact_isClosed_basis_nhds instead;
• instLocallyCompactSpaceOfWeaklyOfGroup, instLocallyCompactSpaceOfWeaklyOfAddGroup: are now implied by WeaklyLocallyCompactSpace.locallyCompactSpace;
• local_isCompact_isClosed_nhds_of_group, local_isCompact_isClosed_nhds_of_addGroup: use isCompact_isClosed_basis_nhds instead;
• exists_isCompact_isClosed_nhds_one, exists_isCompact_isClosed_nhds_zero: use exists_mem_nhds_isCompact_isClosed instead.

Renamed/moved theorems

For each renamed theorem, the old theorem is redefined as a deprecated alias.

• isOpen_setOf_disjoint_nhds_nhds: moved to Constructions;
• isCompact_closure_of_subset_compact -> IsCompact.closure_of_subset;
• IsCompact.measure_eq_infi_isOpen -> IsCompact.measure_eq_iInf_isOpen;
• exists_compact_superset_iff -> exists_isCompact_superset_iff;
• separatedNhds_of_isCompact_isCompact_isClosed -> SeparatedNhds.of_isCompact_isCompact_isClosed;
• separatedNhds_of_isCompact_isCompact -> SeparatedNhds.of_isCompact_isCompact;
• separatedNhds_of_finset_finset -> SeparatedNhds.of_finset_finset;
• point_disjoint_finset_opens_of_t2 -> SeparatedNhds.of_singleton_finset;
• separatedNhds_of_isCompact_isClosed -> SeparatedNhds.of_isCompact_isClosed;
• exists_open_superset_and_isCompact_closure -> exists_isOpen_superset_and_isCompact_closure;
• exists_open_with_compact_closure -> exists_isOpen_mem_isCompact_closure;

@@ -165,16 +165,16 @@ theorem hasCompactMulSupport_def : HasCompactMulSupport f ↔ IsCompact (closure
 #align has_compact_support_def hasCompactSupport_def
 
 @[to_additive]
-theorem exists_compact_iff_hasCompactMulSupport [T2OrLocallyCompactRegularSpace α] :
+theorem exists_compact_iff_hasCompactMulSupport [R1Space α] :
     (∃ K : Set α, IsCompact K ∧ ∀ x, x ∉ K → f x = 1) ↔ HasCompactMulSupport f := by
   simp_rw [← nmem_mulSupport, ← mem_compl_iff, ← subset_def, compl_subset_compl,
-    hasCompactMulSupport_def, exists_compact_superset_iff]
+    hasCompactMulSupport_def, exists_isCompact_superset_iff]
 #align exists_compact_iff_has_compact_mul_support exists_compact_iff_hasCompactMulSupport
 #align exists_compact_iff_has_compact_support exists_compact_iff_hasCompactSupport
 
 namespace HasCompactMulSupport
 @[to_additive]
-theorem intro [T2OrLocallyCompactRegularSpace α] {K : Set α} (hK : IsCompact K)
+theorem intro [R1Space α] {K : Set α} (hK : IsCompact K)
     (hfK : ∀ x, x ∉ K → f x = 1) : HasCompactMulSupport f :=
   exists_compact_iff_hasCompactMulSupport.mp ⟨K, hK, hfK⟩
 #align has_compact_mul_support.intro HasCompactMulSupport.intro
@@ -189,9 +189,9 @@ theorem intro' {K : Set α} (hK : IsCompact K) (h'K : IsClosed K)
   exact IsCompact.of_isClosed_subset hK ( isClosed_mulTSupport f) this
 
 @[to_additive]
-theorem of_mulSupport_subset_isCompact [T2OrLocallyCompactRegularSpace α]
-    {K : Set α} (hK : IsCompact K) (h : mulSupport f ⊆ K) : HasCompactMulSupport f :=
-  isCompact_closure_of_subset_compact hK h
+theorem of_mulSupport_subset_isCompact [R1Space α] {K : Set α}
+    (hK : IsCompact K) (h : mulSupport f ⊆ K) : HasCompactMulSupport f :=
+  hK.closure_of_subset h
 
 @[to_additive]
 theorem isCompact (hf : HasCompactMulSupport f) : IsCompact (mulTSupport f) :=

• Prove that a set is a Gdelta if and only if it is an intersection of open sets indexed by ℕ.
• Cleanup porting todos in the Gdelta file
• Rename cluster_point_of_compact to exists_clusterPt_of_compactSpace
• Generalize the class T2Space to T2OrLocallyCompactRegularSpace in the file Support.lean

@@ -165,7 +165,7 @@ theorem hasCompactMulSupport_def : HasCompactMulSupport f ↔ IsCompact (closure
 #align has_compact_support_def hasCompactSupport_def
 
 @[to_additive]
-theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
+theorem exists_compact_iff_hasCompactMulSupport [T2OrLocallyCompactRegularSpace α] :
     (∃ K : Set α, IsCompact K ∧ ∀ x, x ∉ K → f x = 1) ↔ HasCompactMulSupport f := by
   simp_rw [← nmem_mulSupport, ← mem_compl_iff, ← subset_def, compl_subset_compl,
     hasCompactMulSupport_def, exists_compact_superset_iff]
@@ -174,7 +174,7 @@ theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
 
 namespace HasCompactMulSupport
 @[to_additive]
-theorem intro [T2Space α] {K : Set α} (hK : IsCompact K)
+theorem intro [T2OrLocallyCompactRegularSpace α] {K : Set α} (hK : IsCompact K)
     (hfK : ∀ x, x ∉ K → f x = 1) : HasCompactMulSupport f :=
   exists_compact_iff_hasCompactMulSupport.mp ⟨K, hK, hfK⟩
 #align has_compact_mul_support.intro HasCompactMulSupport.intro
@@ -189,8 +189,8 @@ theorem intro' {K : Set α} (hK : IsCompact K) (h'K : IsClosed K)
   exact IsCompact.of_isClosed_subset hK ( isClosed_mulTSupport f) this
 
 @[to_additive]
-theorem of_mulSupport_subset_isCompact [T2Space α] {K : Set α}
-    (hK : IsCompact K) (h : mulSupport f ⊆ K) : HasCompactMulSupport f :=
+theorem of_mulSupport_subset_isCompact [T2OrLocallyCompactRegularSpace α]
+    {K : Set α} (hK : IsCompact K) (h : mulSupport f ⊆ K) : HasCompactMulSupport f :=
   isCompact_closure_of_subset_compact hK h
 
 @[to_additive]
@@ -272,6 +272,14 @@ theorem comp₂_left (hf : HasCompactMulSupport f)
 #align has_compact_mul_support.comp₂_left HasCompactMulSupport.comp₂_left
 #align has_compact_support.comp₂_left HasCompactSupport.comp₂_left
 
+@[to_additive]
+lemma isCompact_preimage [TopologicalSpace β]
+    (h'f : HasCompactMulSupport f) (hf : Continuous f) {k : Set β} (hk : IsClosed k)
+    (h'k : 1 ∉ k) : IsCompact (f ⁻¹' k) := by
+  apply IsCompact.of_isClosed_subset h'f (hk.preimage hf) (fun x hx ↦ ?_)
+  apply subset_mulTSupport
+  aesop
+
 variable [T2Space α'] (hf : HasCompactMulSupport f) {g : α → α'} (cont : Continuous g)
 
 @[to_additive]

From sphere-eversion. Will be used to show a point-wise version of SmoothPartitionOfUnity.contMDiff_finsum_smul.

Co-authored-by: Oliver Nash <github@olivernash.org>

@@ -420,4 +420,14 @@ theorem locallyFinite_mulSupport_iff [CommMonoid M] {f : ι → X → M} :
     (LocallyFinite fun i ↦ mulSupport <| f i) ↔ LocallyFinite fun i ↦ mulTSupport <| f i :=
   ⟨LocallyFinite.closure, fun H ↦ H.subset fun _ ↦ subset_closure⟩
 
+theorem LocallyFinite.smul_left [Zero R] [Zero M] [SMulWithZero R M]
+    {s : ι → X → R} (h : LocallyFinite fun i ↦ support <| s i) (f : ι → X → M) :
+    LocallyFinite fun i ↦ support <| s i • f i :=
+  h.subset fun i x ↦ mt <| fun h ↦ by rw [Pi.smul_apply', h, zero_smul]
+
+theorem LocallyFinite.smul_right [Zero M] [SMulZeroClass R M]
+    {f : ι → X → M} (h : LocallyFinite fun i ↦ support <| f i) (s : ι → X → R) :
+    LocallyFinite fun i ↦ support <| s i • f i :=
+  h.subset fun i x ↦ mt <| fun h ↦ by rw [Pi.smul_apply', h, smul_zero]
+
 end LocallyFinite

• rename Function.support_smul_subset_right to Function.support_const_smul_subset

From sphere-eversion; I'm just upstreaming it.

Co-authored-by: grunweg <grunweg@posteo.de>

@@ -103,6 +103,10 @@ theorem tsupport_smul_subset_left {M α} [TopologicalSpace X] [Zero M] [Zero α]
   closure_mono <| support_smul_subset_left f g
 #align tsupport_smul_subset_left tsupport_smul_subset_left
 
+theorem tsupport_smul_subset_right {M α} [TopologicalSpace X] [Zero α] [SMulZeroClass M α]
+    (f : X → M) (g : X → α) : (tsupport fun x => f x • g x) ⊆ tsupport g :=
+  closure_mono <| support_smul_subset_right f g
+
 @[to_additive]
 theorem mulTSupport_mul [TopologicalSpace X] [Monoid α] {f g : X → α} :
     (mulTSupport fun x ↦ f x * g x) ⊆ mulTSupport f ∪ mulTSupport g :=

From sphere-eversion; I'm just upstreaming it.

@@ -369,9 +369,9 @@ end MulZeroClass
 
 end CompactSupport2
 
-namespace LocallyFinite
+section LocallyFinite
 
-variable {ι : Type*} {U : ι → Set X} [TopologicalSpace X] [One R]
+variable {ι : Type*} [TopologicalSpace X]
 
 -- porting note: todo: reformulate for any locally finite family of sets
 /-- If a family of functions `f` has locally-finite multiplicative support, subordinate to a family
@@ -380,7 +380,7 @@ of open sets, then for any point we can find a neighbourhood on which only finit
 @[to_additive " If a family of functions `f` has locally-finite support, subordinate to a family of
 open sets, then for any point we can find a neighbourhood on which only finitely-many members of `f`
 are non-zero. "]
-theorem exists_finset_nhd_mulSupport_subset {f : ι → X → R}
+theorem LocallyFinite.exists_finset_nhd_mulSupport_subset {U : ι → Set X} [One R] {f : ι → X → R}
     (hlf : LocallyFinite fun i => mulSupport (f i)) (hso : ∀ i, mulTSupport (f i) ⊆ U i)
     (ho : ∀ i, IsOpen (U i)) (x : X) :
     ∃ (is : Finset ι), ∃ n, n ∈ 𝓝 x ∧ (n ⊆ ⋂ i ∈ is, U i) ∧
@@ -411,4 +411,9 @@ theorem exists_finset_nhd_mulSupport_subset {f : ι → X → R}
 #align locally_finite.exists_finset_nhd_mul_support_subset LocallyFinite.exists_finset_nhd_mulSupport_subset
 #align locally_finite.exists_finset_nhd_support_subset LocallyFinite.exists_finset_nhd_support_subset
 
+@[to_additive]
+theorem locallyFinite_mulSupport_iff [CommMonoid M] {f : ι → X → M} :
+    (LocallyFinite fun i ↦ mulSupport <| f i) ↔ LocallyFinite fun i ↦ mulTSupport <| f i :=
+  ⟨LocallyFinite.closure, fun H ↦ H.subset fun _ ↦ subset_closure⟩
+
 end LocallyFinite

Only add a section; no lemmas are changed. Open the HasCompactSupport namespace more, while we're at it.

@@ -26,7 +26,7 @@ Furthermore, we say that `f` has compact support if the topological support of `
 
 * We write all lemmas for multiplicative functions, and use `@[to_additive]` to get the more common
   additive versions.
-* We do not put the definitions in the `function` namespace, following many other topological
+* We do not put the definitions in the `Function` namespace, following many other topological
   definitions that are in the root namespace (compare `Embedding` vs `Function.Embedding`).
 -/
 
@@ -133,6 +133,16 @@ theorem continuous_of_mulTSupport [TopologicalSpace β] {f : α → β}
 #align continuous_of_mul_tsupport continuous_of_mulTSupport
 #align continuous_of_tsupport continuous_of_tsupport
 
+end
+
+/-! ## Functions with compact support -/
+section CompactSupport
+variable [TopologicalSpace α] [TopologicalSpace α']
+
+variable [One β] [One γ] [One δ]
+
+variable {g : β → γ} {f : α → β} {f₂ : α → γ} {m : β → γ → δ} {x : α}
+
 /-- A function `f` *has compact multiplicative support* or is *compactly supported* if the closure
 of the multiplicative support of `f` is compact. In a T₂ space this is equivalent to `f` being equal
 to `1` outside a compact set. -/
@@ -158,15 +168,16 @@ theorem exists_compact_iff_hasCompactMulSupport [T2Space α] :
 #align exists_compact_iff_has_compact_mul_support exists_compact_iff_hasCompactMulSupport
 #align exists_compact_iff_has_compact_support exists_compact_iff_hasCompactSupport
 
+namespace HasCompactMulSupport
 @[to_additive]
-theorem HasCompactMulSupport.intro [T2Space α] {K : Set α} (hK : IsCompact K)
+theorem intro [T2Space α] {K : Set α} (hK : IsCompact K)
     (hfK : ∀ x, x ∉ K → f x = 1) : HasCompactMulSupport f :=
   exists_compact_iff_hasCompactMulSupport.mp ⟨K, hK, hfK⟩
 #align has_compact_mul_support.intro HasCompactMulSupport.intro
 #align has_compact_support.intro HasCompactSupport.intro
 
 @[to_additive]
-theorem HasCompactMulSupport.intro' {K : Set α} (hK : IsCompact K) (h'K : IsClosed K)
+theorem intro' {K : Set α} (hK : IsCompact K) (h'K : IsClosed K)
     (hfK : ∀ x, x ∉ K → f x = 1) : HasCompactMulSupport f := by
   have : mulTSupport f ⊆ K := by
     rw [← h'K.closure_eq]
@@ -174,18 +185,18 @@ theorem HasCompactMulSupport.intro' {K : Set α} (hK : IsCompact K) (h'K : IsClo
   exact IsCompact.of_isClosed_subset hK ( isClosed_mulTSupport f) this
 
 @[to_additive]
-theorem HasCompactMulSupport.of_mulSupport_subset_isCompact [T2Space α] {K : Set α}
+theorem of_mulSupport_subset_isCompact [T2Space α] {K : Set α}
     (hK : IsCompact K) (h : mulSupport f ⊆ K) : HasCompactMulSupport f :=
   isCompact_closure_of_subset_compact hK h
 
 @[to_additive]
-theorem HasCompactMulSupport.isCompact (hf : HasCompactMulSupport f) : IsCompact (mulTSupport f) :=
+theorem isCompact (hf : HasCompactMulSupport f) : IsCompact (mulTSupport f) :=
   hf
 #align has_compact_mul_support.is_compact HasCompactMulSupport.isCompact
 #align has_compact_support.is_compact HasCompactSupport.isCompact
 
 @[to_additive]
-theorem hasCompactMulSupport_iff_eventuallyEq :
+theorem _root_.hasCompactMulSupport_iff_eventuallyEq :
     HasCompactMulSupport f ↔ f =ᶠ[coclosedCompact α] 1 :=
   ⟨fun h => mem_coclosedCompact.mpr
     ⟨mulTSupport f, isClosed_mulTSupport _, h,
@@ -197,49 +208,49 @@ theorem hasCompactMulSupport_iff_eventuallyEq :
 #align has_compact_support_iff_eventually_eq hasCompactSupport_iff_eventuallyEq
 
 @[to_additive]
-theorem isCompact_range_of_mulSupport_subset_isCompact [TopologicalSpace β]
+theorem _root_.isCompact_range_of_mulSupport_subset_isCompact [TopologicalSpace β]
     (hf : Continuous f) {k : Set α} (hk : IsCompact k) (h'f : mulSupport f ⊆ k) :
     IsCompact (range f) := by
   cases' range_eq_image_or_of_mulSupport_subset h'f with h2 h2 <;> rw [h2]
   exacts [hk.image hf, (hk.image hf).insert 1]
 
 @[to_additive]
-theorem HasCompactMulSupport.isCompact_range [TopologicalSpace β] (h : HasCompactMulSupport f)
+theorem isCompact_range [TopologicalSpace β] (h : HasCompactMulSupport f)
     (hf : Continuous f) : IsCompact (range f) :=
   isCompact_range_of_mulSupport_subset_isCompact hf h (subset_mulTSupport f)
 #align has_compact_mul_support.is_compact_range HasCompactMulSupport.isCompact_range
 #align has_compact_support.is_compact_range HasCompactSupport.isCompact_range
 
 @[to_additive]
-theorem HasCompactMulSupport.mono' {f' : α → γ} (hf : HasCompactMulSupport f)
+theorem mono' {f' : α → γ} (hf : HasCompactMulSupport f)
     (hff' : mulSupport f' ⊆ mulTSupport f) : HasCompactMulSupport f' :=
   IsCompact.of_isClosed_subset hf isClosed_closure <| closure_minimal hff' isClosed_closure
 #align has_compact_mul_support.mono' HasCompactMulSupport.mono'
 #align has_compact_support.mono' HasCompactSupport.mono'
 
 @[to_additive]
-theorem HasCompactMulSupport.mono {f' : α → γ} (hf : HasCompactMulSupport f)
+theorem mono {f' : α → γ} (hf : HasCompactMulSupport f)
     (hff' : mulSupport f' ⊆ mulSupport f) : HasCompactMulSupport f' :=
   hf.mono' <| hff'.trans subset_closure
 #align has_compact_mul_support.mono HasCompactMulSupport.mono
 #align has_compact_support.mono HasCompactSupport.mono
 
 @[to_additive]
-theorem HasCompactMulSupport.comp_left (hf : HasCompactMulSupport f) (hg : g 1 = 1) :
+theorem comp_left (hf : HasCompactMulSupport f) (hg : g 1 = 1) :
     HasCompactMulSupport (g ∘ f) :=
   hf.mono <| mulSupport_comp_subset hg f
 #align has_compact_mul_support.comp_left HasCompactMulSupport.comp_left
 #align has_compact_support.comp_left HasCompactSupport.comp_left
 
 @[to_additive]
-theorem hasCompactMulSupport_comp_left (hg : ∀ {x}, g x = 1 ↔ x = 1) :
+theorem _root_.hasCompactMulSupport_comp_left (hg : ∀ {x}, g x = 1 ↔ x = 1) :
     HasCompactMulSupport (g ∘ f) ↔ HasCompactMulSupport f := by
   simp_rw [hasCompactMulSupport_def, mulSupport_comp_eq g (@hg) f]
 #align has_compact_mul_support_comp_left hasCompactMulSupport_comp_left
 #align has_compact_support_comp_left hasCompactSupport_comp_left
 
 @[to_additive]
-theorem HasCompactMulSupport.comp_closedEmbedding (hf : HasCompactMulSupport f) {g : α' → α}
+theorem comp_closedEmbedding (hf : HasCompactMulSupport f) {g : α' → α}
     (hg : ClosedEmbedding g) : HasCompactMulSupport (f ∘ g) := by
   rw [hasCompactMulSupport_def, Function.mulSupport_comp_eq_preimage]
   refine' IsCompact.of_isClosed_subset (hg.isCompact_preimage hf) isClosed_closure _
@@ -249,7 +260,7 @@ theorem HasCompactMulSupport.comp_closedEmbedding (hf : HasCompactMulSupport f)
 #align has_compact_support.comp_closed_embedding HasCompactSupport.comp_closedEmbedding
 
 @[to_additive]
-theorem HasCompactMulSupport.comp₂_left (hf : HasCompactMulSupport f)
+theorem comp₂_left (hf : HasCompactMulSupport f)
     (hf₂ : HasCompactMulSupport f₂) (hm : m 1 1 = 1) :
     HasCompactMulSupport fun x => m (f x) (f₂ x) := by
   rw [hasCompactMulSupport_iff_eventuallyEq] at hf hf₂ ⊢
@@ -257,8 +268,6 @@ theorem HasCompactMulSupport.comp₂_left (hf : HasCompactMulSupport f)
 #align has_compact_mul_support.comp₂_left HasCompactMulSupport.comp₂_left
 #align has_compact_support.comp₂_left HasCompactSupport.comp₂_left
 
-namespace HasCompactMulSupport
-
 variable [T2Space α'] (hf : HasCompactMulSupport f) {g : α → α'} (cont : Continuous g)
 
 @[to_additive]
@@ -291,8 +300,10 @@ theorem continuous_extend_one [TopologicalSpace β] {U : Set α'} (hU : IsOpen U
 
 end HasCompactMulSupport
 
-end
+end CompactSupport
 
+/-! ## Functions with compact support: algebraic operations -/
+section CompactSupport2
 section Monoid
 
 variable [TopologicalSpace α] [Monoid β]
@@ -356,6 +367,8 @@ theorem HasCompactSupport.mul_left (hf : HasCompactSupport f') : HasCompactSuppo
 
 end MulZeroClass
 
+end CompactSupport2
+
 namespace LocallyFinite
 
 variable {ι : Type*} {U : ι → Set X} [TopologicalSpace X] [One R]

cherry-picked from #9347

Co-Authored-By: @digama0

@@ -5,6 +5,7 @@ Authors: Floris van Doorn, Patrick Massot
 -/
 import Mathlib.Algebra.Module.Basic
 import Mathlib.Topology.Separation
+import Mathlib.Algebra.Group.Defs
 
 #align_import topology.support from "leanprover-community/mathlib"@"d90e4e186f1d18e375dcd4e5b5f6364b01cb3e46"
 

Rename

• Covby → CovBy, Wcovby → WCovBy
• *covby* → *covBy*
• wcovby.finset_val → WCovBy.finset_val, wcovby.finset_coe → WCovBy.finset_coe
• Covby.is_coatom → CovBy.isCoatom

@@ -81,7 +81,7 @@ theorem range_subset_insert_image_mulTSupport (f : X → α) :
 @[to_additive]
 theorem range_eq_image_mulTSupport_or (f : X → α) :
     range f = f '' mulTSupport f ∨ range f = insert 1 (f '' mulTSupport f) :=
-  (wcovby_insert _ _).eq_or_eq (image_subset_range _ _) (range_subset_insert_image_mulTSupport f)
+  (wcovBy_insert _ _).eq_or_eq (image_subset_range _ _) (range_subset_insert_image_mulTSupport f)
 #align range_eq_image_mul_tsupport_or range_eq_image_mulTSupport_or
 #align range_eq_image_tsupport_or range_eq_image_tsupport_or
 

From the hairer branch.

@@ -102,6 +102,13 @@ theorem tsupport_smul_subset_left {M α} [TopologicalSpace X] [Zero M] [Zero α]
   closure_mono <| support_smul_subset_left f g
 #align tsupport_smul_subset_left tsupport_smul_subset_left
 
+@[to_additive]
+theorem mulTSupport_mul [TopologicalSpace X] [Monoid α] {f g : X → α} :
+    (mulTSupport fun x ↦ f x * g x) ⊆ mulTSupport f ∪ mulTSupport g :=
+  closure_minimal
+    ((mulSupport_mul f g).trans (union_subset_union (subset_mulTSupport _) (subset_mulTSupport _)))
+    (isClosed_closure.union isClosed_closure)
+
 section
 
 variable [TopologicalSpace α] [TopologicalSpace α']

Function.support is a very basic definition. Nevertheless, it is a pretty heavy import because it imports most objects a support lemma can be written about.

This PR reverses the dependencies between those objects and Function.support, so that the latter can become a much more lightweight import.

Only two import could not easily be reversed, namely the ones to Data.Set.Finite and Order.ConditionallyCompleteLattice.Basic, so I created two new files instead.

I credit:

• Yury for https://github.com/leanprover-community/mathlib/pull/6791
• Oliver for https://github.com/leanprover-community/mathlib/pull/7439

@@ -3,6 +3,7 @@ Copyright (c) 2022 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn, Patrick Massot
 -/
+import Mathlib.Algebra.Module.Basic
 import Mathlib.Topology.Separation
 
 #align_import topology.support from "leanprover-community/mathlib"@"d90e4e186f1d18e375dcd4e5b5f6364b01cb3e46"

A stronger version of #8800, the differences are:

• assume either IsSigmaCompact U or SigmaCompactSpace M;

• only need test functions satisfying tsupport g ⊆ U rather than support g ⊆ U;

• requires LocallyIntegrableOn U rather than LocallyIntegrable on the whole space.

Also fills in some missing APIs around the manifold and measure theory libraries.

Co-authored-by: sgouezel <sebastien.gouezel@univ-rennes1.fr> Co-authored-by: Junyan Xu <junyanxu.math@gmail.com>

@@ -248,6 +248,40 @@ theorem HasCompactMulSupport.comp₂_left (hf : HasCompactMulSupport f)
 #align has_compact_mul_support.comp₂_left HasCompactMulSupport.comp₂_left
 #align has_compact_support.comp₂_left HasCompactSupport.comp₂_left
 
+namespace HasCompactMulSupport
+
+variable [T2Space α'] (hf : HasCompactMulSupport f) {g : α → α'} (cont : Continuous g)
+
+@[to_additive]
+theorem mulTSupport_extend_one_subset :
+    mulTSupport (g.extend f 1) ⊆ g '' mulTSupport f :=
+  (hf.image cont).isClosed.closure_subset_iff.mpr <|
+    mulSupport_extend_one_subset.trans (image_subset g subset_closure)
+
+@[to_additive]
+theorem extend_one : HasCompactMulSupport (g.extend f 1) :=
+  HasCompactMulSupport.of_mulSupport_subset_isCompact (hf.image cont)
+    (subset_closure.trans <| hf.mulTSupport_extend_one_subset cont)
+
+@[to_additive]
+theorem mulTSupport_extend_one (inj : g.Injective) :
+    mulTSupport (g.extend f 1) = g '' mulTSupport f :=
+  (hf.mulTSupport_extend_one_subset cont).antisymm <|
+    (image_closure_subset_closure_image cont).trans
+      (closure_mono (mulSupport_extend_one inj).superset)
+
+@[to_additive]
+theorem continuous_extend_one [TopologicalSpace β] {U : Set α'} (hU : IsOpen U) {f : U → β}
+    (cont : Continuous f) (supp : HasCompactMulSupport f) :
+    Continuous (Subtype.val.extend f 1) :=
+  continuous_of_mulTSupport fun x h ↦ by
+    rw [show x = ↑(⟨x, Subtype.coe_image_subset _ _
+      (supp.mulTSupport_extend_one_subset continuous_subtype_val h)⟩ : U) by rfl,
+      ← (hU.openEmbedding_subtype_val).continuousAt_iff, extend_comp Subtype.val_injective]
+    exact cont.continuousAt
+
+end HasCompactMulSupport
+
 end
 
 section Monoid

@@ -196,8 +196,8 @@ theorem isCompact_range_of_mulSupport_subset_isCompact [TopologicalSpace β]
 
 @[to_additive]
 theorem HasCompactMulSupport.isCompact_range [TopologicalSpace β] (h : HasCompactMulSupport f)
-    (hf : Continuous f) : IsCompact (range f) := by
-  apply isCompact_range_of_mulSupport_subset_isCompact hf h (subset_mulTSupport f)
+    (hf : Continuous f) : IsCompact (range f) :=
+  isCompact_range_of_mulSupport_subset_isCompact hf h (subset_mulTSupport f)
 #align has_compact_mul_support.is_compact_range HasCompactMulSupport.isCompact_range
 #align has_compact_support.is_compact_range HasCompactSupport.isCompact_range
 

Useful to uniformize proofs for T2 spaces and regular spaces, notably to discuss regular measures in topological groups.

@@ -156,6 +156,14 @@ theorem HasCompactMulSupport.intro [T2Space α] {K : Set α} (hK : IsCompact K)
 #align has_compact_mul_support.intro HasCompactMulSupport.intro
 #align has_compact_support.intro HasCompactSupport.intro
 
+@[to_additive]
+theorem HasCompactMulSupport.intro' {K : Set α} (hK : IsCompact K) (h'K : IsClosed K)
+    (hfK : ∀ x, x ∉ K → f x = 1) : HasCompactMulSupport f := by
+  have : mulTSupport f ⊆ K := by
+    rw [← h'K.closure_eq]
+    apply closure_mono (mulSupport_subset_iff'.2 hfK)
+  exact IsCompact.of_isClosed_subset hK ( isClosed_mulTSupport f) this
+
 @[to_additive]
 theorem HasCompactMulSupport.of_mulSupport_subset_isCompact [T2Space α] {K : Set α}
     (hK : IsCompact K) (h : mulSupport f ⊆ K) : HasCompactMulSupport f :=
@@ -179,11 +187,17 @@ theorem hasCompactMulSupport_iff_eventuallyEq :
 #align has_compact_mul_support_iff_eventually_eq hasCompactMulSupport_iff_eventuallyEq
 #align has_compact_support_iff_eventually_eq hasCompactSupport_iff_eventuallyEq
 
+@[to_additive]
+theorem isCompact_range_of_mulSupport_subset_isCompact [TopologicalSpace β]
+    (hf : Continuous f) {k : Set α} (hk : IsCompact k) (h'f : mulSupport f ⊆ k) :
+    IsCompact (range f) := by
+  cases' range_eq_image_or_of_mulSupport_subset h'f with h2 h2 <;> rw [h2]
+  exacts [hk.image hf, (hk.image hf).insert 1]
+
 @[to_additive]
 theorem HasCompactMulSupport.isCompact_range [TopologicalSpace β] (h : HasCompactMulSupport f)
     (hf : Continuous f) : IsCompact (range f) := by
-  cases' range_eq_image_mulTSupport_or f with h2 h2 <;> rw [h2]
-  exacts [h.image hf, (h.image hf).insert 1]
+  apply isCompact_range_of_mulSupport_subset_isCompact hf h (subset_mulTSupport f)
 #align has_compact_mul_support.is_compact_range HasCompactMulSupport.isCompact_range
 #align has_compact_support.is_compact_range HasCompactSupport.isCompact_range
 

mathport was forgetting a space in filter_upwards [...]with instead of filter_upwards [...] with.

@@ -230,7 +230,7 @@ theorem HasCompactMulSupport.comp₂_left (hf : HasCompactMulSupport f)
     (hf₂ : HasCompactMulSupport f₂) (hm : m 1 1 = 1) :
     HasCompactMulSupport fun x => m (f x) (f₂ x) := by
   rw [hasCompactMulSupport_iff_eventuallyEq] at hf hf₂ ⊢
-  filter_upwards [hf, hf₂]using fun x hx hx₂ => by simp_rw [hx, hx₂, Pi.one_apply, hm]
+  filter_upwards [hf, hf₂] using fun x hx hx₂ => by simp_rw [hx, hx₂, Pi.one_apply, hm]
 #align has_compact_mul_support.comp₂_left HasCompactMulSupport.comp₂_left
 #align has_compact_support.comp₂_left HasCompactSupport.comp₂_left
 

As discussed on Zulip.

Co-authored-by: grunweg <grunweg@posteo.de>

@@ -175,7 +175,7 @@ theorem hasCompactMulSupport_iff_eventuallyEq :
       fun _ => not_imp_comm.mpr fun hx => subset_mulTSupport f hx⟩,
     fun h =>
       let ⟨_C, hC⟩ := mem_coclosed_compact'.mp h
-      isCompact_of_isClosed_subset hC.2.1 (isClosed_mulTSupport _) (closure_minimal hC.2.2 hC.1)⟩
+      IsCompact.of_isClosed_subset hC.2.1 (isClosed_mulTSupport _) (closure_minimal hC.2.2 hC.1)⟩
 #align has_compact_mul_support_iff_eventually_eq hasCompactMulSupport_iff_eventuallyEq
 #align has_compact_support_iff_eventually_eq hasCompactSupport_iff_eventuallyEq
 
@@ -190,7 +190,7 @@ theorem HasCompactMulSupport.isCompact_range [TopologicalSpace β] (h : HasCompa
 @[to_additive]
 theorem HasCompactMulSupport.mono' {f' : α → γ} (hf : HasCompactMulSupport f)
     (hff' : mulSupport f' ⊆ mulTSupport f) : HasCompactMulSupport f' :=
-  isCompact_of_isClosed_subset hf isClosed_closure <| closure_minimal hff' isClosed_closure
+  IsCompact.of_isClosed_subset hf isClosed_closure <| closure_minimal hff' isClosed_closure
 #align has_compact_mul_support.mono' HasCompactMulSupport.mono'
 #align has_compact_support.mono' HasCompactSupport.mono'
 
@@ -219,7 +219,7 @@ theorem hasCompactMulSupport_comp_left (hg : ∀ {x}, g x = 1 ↔ x = 1) :
 theorem HasCompactMulSupport.comp_closedEmbedding (hf : HasCompactMulSupport f) {g : α' → α}
     (hg : ClosedEmbedding g) : HasCompactMulSupport (f ∘ g) := by
   rw [hasCompactMulSupport_def, Function.mulSupport_comp_eq_preimage]
-  refine' isCompact_of_isClosed_subset (hg.isCompact_preimage hf) isClosed_closure _
+  refine' IsCompact.of_isClosed_subset (hg.isCompact_preimage hf) isClosed_closure _
   rw [hg.toEmbedding.closure_eq_preimage_closure_image]
   exact preimage_mono (closure_mono <| image_preimage_subset _ _)
 #align has_compact_mul_support.comp_closed_embedding HasCompactMulSupport.comp_closedEmbedding

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

This has nice performance benefits.

@@ -31,7 +31,7 @@ Furthermore, we say that `f` has compact support if the topological support of `
 
 open Function Set Filter Topology
 
-variable {X α α' β γ δ M E R : Type _}
+variable {X α α' β γ δ M E R : Type*}
 
 section One
 
@@ -84,12 +84,12 @@ theorem range_eq_image_mulTSupport_or (f : X → α) :
 #align range_eq_image_mul_tsupport_or range_eq_image_mulTSupport_or
 #align range_eq_image_tsupport_or range_eq_image_tsupport_or
 
-theorem tsupport_mul_subset_left {α : Type _} [MulZeroClass α] {f g : X → α} :
+theorem tsupport_mul_subset_left {α : Type*} [MulZeroClass α] {f g : X → α} :
     (tsupport fun x => f x * g x) ⊆ tsupport f :=
   closure_mono (support_mul_subset_left _ _)
 #align tsupport_mul_subset_left tsupport_mul_subset_left
 
-theorem tsupport_mul_subset_right {α : Type _} [MulZeroClass α] {f g : X → α} :
+theorem tsupport_mul_subset_right {α : Type*} [MulZeroClass α] {f g : X → α} :
     (tsupport fun x => f x * g x) ⊆ tsupport g :=
   closure_mono (support_mul_subset_right _ _)
 #align tsupport_mul_subset_right tsupport_mul_subset_right
@@ -301,7 +301,7 @@ end MulZeroClass
 
 namespace LocallyFinite
 
-variable {ι : Type _} {U : ι → Set X} [TopologicalSpace X] [One R]
+variable {ι : Type*} {U : ι → Set X} [TopologicalSpace X] [One R]
 
 -- porting note: todo: reformulate for any locally finite family of sets
 /-- If a family of functions `f` has locally-finite multiplicative support, subordinate to a family

@@ -156,6 +156,11 @@ theorem HasCompactMulSupport.intro [T2Space α] {K : Set α} (hK : IsCompact K)
 #align has_compact_mul_support.intro HasCompactMulSupport.intro
 #align has_compact_support.intro HasCompactSupport.intro
 
+@[to_additive]
+theorem HasCompactMulSupport.of_mulSupport_subset_isCompact [T2Space α] {K : Set α}
+    (hK : IsCompact K) (h : mulSupport f ⊆ K) : HasCompactMulSupport f :=
+  isCompact_closure_of_subset_compact hK h
+
 @[to_additive]
 theorem HasCompactMulSupport.isCompact (hf : HasCompactMulSupport f) : IsCompact (mulTSupport f) :=
   hf

• depends on: #5966

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

@@ -2,14 +2,11 @@
 Copyright (c) 2022 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn, Patrick Massot
-
-! This file was ported from Lean 3 source module topology.support
-! leanprover-community/mathlib commit d90e4e186f1d18e375dcd4e5b5f6364b01cb3e46
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Topology.Separation
 
+#align_import topology.support from "leanprover-community/mathlib"@"d90e4e186f1d18e375dcd4e5b5f6364b01cb3e46"
+
 /-!
 # The topological support of a function
 

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

@@ -318,7 +318,7 @@ theorem exists_finset_nhd_mulSupport_subset {f : ι → X → R}
     let is := hnf.toFinset.filter fun i => x ∈ U i
     let js := hnf.toFinset.filter fun j => x ∉ U j
     refine'
-      ⟨is, (n ∩ ⋂ j ∈ js, mulTSupport (f j)ᶜ) ∩ ⋂ i ∈ is, U i, inter_mem (inter_mem hn _) _,
+      ⟨is, (n ∩ ⋂ j ∈ js, (mulTSupport (f j))ᶜ) ∩ ⋂ i ∈ is, U i, inter_mem (inter_mem hn _) _,
         inter_subset_right _ _, fun z hz => _⟩
     · exact (biInter_finset_mem js).mpr fun j hj => IsClosed.compl_mem_nhds (isClosed_mulTSupport _)
         (Set.not_mem_subset (hso j) (Finset.mem_filter.mp hj).2)

Changes are of the form

• some_tactic at h⊢ -> some_tactic at h ⊢
• some_tactic at h -> some_tactic at h

@@ -227,7 +227,7 @@ theorem HasCompactMulSupport.comp_closedEmbedding (hf : HasCompactMulSupport f)
 theorem HasCompactMulSupport.comp₂_left (hf : HasCompactMulSupport f)
     (hf₂ : HasCompactMulSupport f₂) (hm : m 1 1 = 1) :
     HasCompactMulSupport fun x => m (f x) (f₂ x) := by
-  rw [hasCompactMulSupport_iff_eventuallyEq] at hf hf₂⊢
+  rw [hasCompactMulSupport_iff_eventuallyEq] at hf hf₂ ⊢
   filter_upwards [hf, hf₂]using fun x hx hx₂ => by simp_rw [hx, hx₂, Pi.one_apply, hm]
 #align has_compact_mul_support.comp₂_left HasCompactMulSupport.comp₂_left
 #align has_compact_support.comp₂_left HasCompactSupport.comp₂_left

Too often tempted to change these during other PRs, so doing a mass edit here.

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

@@ -181,7 +181,7 @@ theorem hasCompactMulSupport_iff_eventuallyEq :
 theorem HasCompactMulSupport.isCompact_range [TopologicalSpace β] (h : HasCompactMulSupport f)
     (hf : Continuous f) : IsCompact (range f) := by
   cases' range_eq_image_mulTSupport_or f with h2 h2 <;> rw [h2]
-  exacts[h.image hf, (h.image hf).insert 1]
+  exacts [h.image hf, (h.image hf).insert 1]
 #align has_compact_mul_support.is_compact_range HasCompactMulSupport.isCompact_range
 #align has_compact_support.is_compact_range HasCompactSupport.isCompact_range
 

As discussed on Zulip

Renames

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

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

@@ -320,14 +320,14 @@ theorem exists_finset_nhd_mulSupport_subset {f : ι → X → R}
     refine'
       ⟨is, (n ∩ ⋂ j ∈ js, mulTSupport (f j)ᶜ) ∩ ⋂ i ∈ is, U i, inter_mem (inter_mem hn _) _,
         inter_subset_right _ _, fun z hz => _⟩
-    · exact (binterᵢ_finset_mem js).mpr fun j hj => IsClosed.compl_mem_nhds (isClosed_mulTSupport _)
+    · exact (biInter_finset_mem js).mpr fun j hj => IsClosed.compl_mem_nhds (isClosed_mulTSupport _)
         (Set.not_mem_subset (hso j) (Finset.mem_filter.mp hj).2)
-    · exact (binterᵢ_finset_mem is).mpr fun i hi => (ho i).mem_nhds (Finset.mem_filter.mp hi).2
+    · exact (biInter_finset_mem is).mpr fun i hi => (ho i).mem_nhds (Finset.mem_filter.mp hi).2
     · have hzn : z ∈ n := by
         rw [inter_assoc] at hz
         exact mem_of_mem_inter_left hz
       replace hz := mem_of_mem_inter_right (mem_of_mem_inter_left hz)
-      simp only [Finset.mem_filter, Finite.mem_toFinset, mem_setOf_eq, mem_interᵢ, and_imp] at hz
+      simp only [Finset.mem_filter, Finite.mem_toFinset, mem_setOf_eq, mem_iInter, and_imp] at hz
       suffices (mulSupport fun i => f i z) ⊆ hnf.toFinset by
         refine' hnf.toFinset.subset_coe_filter_of_subset_forall _ this fun i hi => _
         specialize hz i ⟨z, ⟨hi, hzn⟩⟩
@@ -340,4 +340,3 @@ theorem exists_finset_nhd_mulSupport_subset {f : ι → X → R}
 #align locally_finite.exists_finset_nhd_support_subset LocallyFinite.exists_finset_nhd_support_subset
 
 end LocallyFinite
-