File: Mathlib/Topology/Support.lean

full_name: tsupport
code: /-- The topological support of a function is the closure of its support, i.e. the closure of the
  set of all elements where the function is not equal to 1. -/
@[to_additive " The topological support of a function is the closure of its support. i.e. the
closure of the set of all elements where the function is nonzero. "]
def mulTSupport (f : X → α) : Set X 
goal: Set X

full_name: mulTSupport
code: /-- The topological support of a function is the closure of its support, i.e. the closure of the
  set of all elements where the function is not equal to 1. -/
@[to_additive " The topological support of a function is the closure of its support. i.e. the
closure of the set of all elements where the function is nonzero. "]
def mulTSupport (f : X → α) : Set X 
goal: Set X

full_name: subset_tsupport
code: @[to_additive]
theorem subset_mulTSupport (f : X → α) : mulSupport f ⊆ mulTSupport f 
goal: Function.support f ⊆ tsupport f

full_name: subset_mulTSupport
code: @[to_additive]
theorem subset_mulTSupport (f : X → α) : mulSupport f ⊆ mulTSupport f 
goal: Function.mulSupport f ⊆ mulTSupport f

full_name: isClosed_mulTSupport
code: @[to_additive]
theorem isClosed_mulTSupport (f : X → α) : IsClosed (mulTSupport f) 
goal: IsClosed (mulTSupport f)

full_name: isClosed_tsupport
code: @[to_additive]
theorem isClosed_mulTSupport (f : X → α) : IsClosed (mulTSupport f) 
goal: IsClosed (tsupport f)

full_name: mulTSupport_eq_empty_iff
code: @[to_additive]
theorem mulTSupport_eq_empty_iff {f : X → α} : mulTSupport f = ∅ ↔ f = 1 
goal: mulTSupport f = ∅ ↔ f = 1

full_name: tsupport_eq_empty_iff
code: @[to_additive]
theorem mulTSupport_eq_empty_iff {f : X → α} : mulTSupport f = ∅ ↔ f = 1 
goal: tsupport f = ∅ ↔ f = 0

full_name: image_eq_one_of_nmem_mulTSupport
code: @[to_additive]
theorem image_eq_one_of_nmem_mulTSupport {f : X → α} {x : X} (hx : x ∉ mulTSupport f) : f x = 1 
goal: f x = 1

full_name: image_eq_zero_of_nmem_tsupport
code: @[to_additive]
theorem image_eq_one_of_nmem_mulTSupport {f : X → α} {x : X} (hx : x ∉ mulTSupport f) : f x = 1 
goal: f x = 0

full_name: range_subset_insert_image_mulTSupport
code: @[to_additive]
theorem range_subset_insert_image_mulTSupport (f : X → α) :
    range f ⊆ insert 1 (f '' mulTSupport f) 
goal: Set.range f ⊆ insert 1 (f '' mulTSupport f)

full_name: range_subset_insert_image_tsupport
code: @[to_additive]
theorem range_subset_insert_image_mulTSupport (f : X → α) :
    range f ⊆ insert 1 (f '' mulTSupport f) 
goal: Set.range f ⊆ insert 0 (f '' tsupport f)

full_name: range_eq_image_mulTSupport_or
code: @[to_additive]
theorem range_eq_image_mulTSupport_or (f : X → α) :
    range f = f '' mulTSupport f ∨ range f = insert 1 (f '' mulTSupport f) 
goal: Set.range f = f '' mulTSupport f ∨ Set.range f = insert 1 (f '' mulTSupport f)

full_name: range_eq_image_tsupport_or
code: @[to_additive]
theorem range_eq_image_mulTSupport_or (f : X → α) :
    range f = f '' mulTSupport f ∨ range f = insert 1 (f '' mulTSupport f) 
goal: Set.range f = f '' tsupport f ∨ Set.range f = insert 0 (f '' tsupport f)

full_name: tsupport_mul_subset_left
code: theorem tsupport_mul_subset_left {α : Type*} [MulZeroClass α] {f g : X → α} :
    (tsupport fun x => f x * g x) ⊆ tsupport f 
goal: (tsupport fun x => f x * g x) ⊆ tsupport f

full_name: tsupport_mul_subset_right
code: theorem tsupport_mul_subset_right {α : Type*} [MulZeroClass α] {f g : X → α} :
    (tsupport fun x => f x * g x) ⊆ tsupport g 
goal: (tsupport fun x => f x * g x) ⊆ tsupport g

full_name: tsupport_smul_subset_left
code: 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 
goal: (tsupport fun x => f x • g x) ⊆ tsupport f

full_name: tsupport_smul_subset_right
code: 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 
goal: (tsupport fun x => f x • g x) ⊆ tsupport g

full_name: tsupport_add
code: @[to_additive]
theorem mulTSupport_mul [TopologicalSpace X] [Monoid α] {f g : X → α} :
    (mulTSupport fun x ↦ f x * g x) ⊆ mulTSupport f ∪ mulTSupport g 
goal: (tsupport fun x => f x + g x) ⊆ tsupport f ∪ tsupport g

full_name: mulTSupport_mul
code: @[to_additive]
theorem mulTSupport_mul [TopologicalSpace X] [Monoid α] {f g : X → α} :
    (mulTSupport fun x ↦ f x * g x) ⊆ mulTSupport f ∪ mulTSupport g 
goal: (mulTSupport fun x => f x * g x) ⊆ mulTSupport f ∪ mulTSupport g

full_name: not_mem_mulTSupport_iff_eventuallyEq
code: @[to_additive]
theorem not_mem_mulTSupport_iff_eventuallyEq : x ∉ mulTSupport f ↔ f =ᶠ[𝓝 x] 1 
goal: x ∉ mulTSupport f ↔ f =ᶠ[𝓝 x] 1

full_name: not_mem_tsupport_iff_eventuallyEq
code: @[to_additive]
theorem not_mem_mulTSupport_iff_eventuallyEq : x ∉ mulTSupport f ↔ f =ᶠ[𝓝 x] 1 
goal: x ∉ tsupport f ↔ f =ᶠ[𝓝 x] 0

full_name: continuous_of_tsupport
code: @[to_additive]
theorem continuous_of_mulTSupport [TopologicalSpace β] {f : α → β}
    (hf : ∀ x ∈ mulTSupport f, ContinuousAt f x) : Continuous f 
goal: Continuous f

full_name: continuous_of_mulTSupport
code: @[to_additive]
theorem continuous_of_mulTSupport [TopologicalSpace β] {f : α → β}
    (hf : ∀ x ∈ mulTSupport f, ContinuousAt f x) : Continuous f 
goal: Continuous f

full_name: HasCompactSupport
code: /-- 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. -/
@[to_additive " A function `f` *has compact support* or is *compactly supported* if the closure of
the support of `f` is compact. In a T₂ space this is equivalent to `f` being equal to `0` outside a
compact set. "]
def HasCompactMulSupport (f : α → β) : Prop 
goal: Prop

full_name: HasCompactMulSupport
code: /-- 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. -/
@[to_additive " A function `f` *has compact support* or is *compactly supported* if the closure of
the support of `f` is compact. In a T₂ space this is equivalent to `f` being equal to `0` outside a
compact set. "]
def HasCompactMulSupport (f : α → β) : Prop 
goal: Prop

full_name: hasCompactSupport_def
code: @[to_additive]
theorem hasCompactMulSupport_def : HasCompactMulSupport f ↔ IsCompact (closure (mulSupport f)) 
goal: HasCompactSupport f ↔ IsCompact (closure (Function.support f))

full_name: hasCompactMulSupport_def
code: @[to_additive]
theorem hasCompactMulSupport_def : HasCompactMulSupport f ↔ IsCompact (closure (mulSupport f)) 
goal: HasCompactMulSupport f ↔ IsCompact (closure (Function.mulSupport f))

full_name: exists_compact_iff_hasCompactMulSupport
code: @[to_additive]
theorem exists_compact_iff_hasCompactMulSupport [R1Space α] :
    (∃ K : Set α, IsCompact K ∧ ∀ x, x ∉ K → f x = 1) ↔ HasCompactMulSupport f 
goal: (∃ K, IsCompact K ∧ ∀ x ∉ K, f x = 1) ↔ HasCompactMulSupport f

full_name: exists_compact_iff_hasCompactSupport
code: @[to_additive]
theorem exists_compact_iff_hasCompactMulSupport [R1Space α] :
    (∃ K : Set α, IsCompact K ∧ ∀ x, x ∉ K → f x = 1) ↔ HasCompactMulSupport f 
goal: (∃ K, IsCompact K ∧ ∀ x ∉ K, f x = 0) ↔ HasCompactSupport f

full_name: HasCompactMulSupport.intro
code: @[to_additive]
theorem intro [R1Space α] {K : Set α} (hK : IsCompact K)
    (hfK : ∀ x, x ∉ K → f x = 1) : HasCompactMulSupport f 
goal: HasCompactMulSupport f

full_name: HasCompactSupport.intro
code: @[to_additive]
theorem intro [R1Space α] {K : Set α} (hK : IsCompact K)
    (hfK : ∀ x, x ∉ K → f x = 1) : HasCompactMulSupport f 
goal: HasCompactSupport f

full_name: HasCompactMulSupport.intro'
code: @[to_additive]
theorem intro' {K : Set α} (hK : IsCompact K) (h'K : IsClosed K)
    (hfK : ∀ x, x ∉ K → f x = 1) : HasCompactMulSupport f 
goal: HasCompactMulSupport f

full_name: HasCompactSupport.intro'
code: @[to_additive]
theorem intro' {K : Set α} (hK : IsCompact K) (h'K : IsClosed K)
    (hfK : ∀ x, x ∉ K → f x = 1) : HasCompactMulSupport f 
goal: HasCompactSupport f

full_name: HasCompactSupport.of_support_subset_isCompact
code: @[to_additive]
theorem of_mulSupport_subset_isCompact [R1Space α] {K : Set α}
    (hK : IsCompact K) (h : mulSupport f ⊆ K) : HasCompactMulSupport f 
goal: HasCompactSupport f

full_name: HasCompactMulSupport.of_mulSupport_subset_isCompact
code: @[to_additive]
theorem of_mulSupport_subset_isCompact [R1Space α] {K : Set α}
    (hK : IsCompact K) (h : mulSupport f ⊆ K) : HasCompactMulSupport f 
goal: HasCompactMulSupport f

full_name: HasCompactSupport.isCompact
code: @[to_additive]
theorem isCompact (hf : HasCompactMulSupport f) : IsCompact (mulTSupport f) 
goal: IsCompact (tsupport f)

full_name: HasCompactMulSupport.isCompact
code: @[to_additive]
theorem isCompact (hf : HasCompactMulSupport f) : IsCompact (mulTSupport f) 
goal: IsCompact (mulTSupport f)

full_name: hasCompactMulSupport_iff_eventuallyEq
code: @[to_additive]
theorem _root_.hasCompactMulSupport_iff_eventuallyEq :
    HasCompactMulSupport f ↔ f =ᶠ[coclosedCompact α] 1 
goal: HasCompactMulSupport f ↔ f =ᶠ[Filter.coclosedCompact α] 1

full_name: hasCompactSupport_iff_eventuallyEq
code: @[to_additive]
theorem _root_.hasCompactMulSupport_iff_eventuallyEq :
    HasCompactMulSupport f ↔ f =ᶠ[coclosedCompact α] 1 
goal: HasCompactSupport f ↔ f =ᶠ[Filter.coclosedCompact α] 0

full_name: isCompact_range_of_support_subset_isCompact
code: @[to_additive]
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) 
goal: IsCompact (Set.range f)

full_name: isCompact_range_of_mulSupport_subset_isCompact
code: @[to_additive]
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) 
goal: IsCompact (Set.range f)

full_name: HasCompactMulSupport.isCompact_range
code: @[to_additive]
theorem isCompact_range [TopologicalSpace β] (h : HasCompactMulSupport f)
    (hf : Continuous f) : IsCompact (range f) 
goal: IsCompact (Set.range f)

full_name: HasCompactSupport.isCompact_range
code: @[to_additive]
theorem isCompact_range [TopologicalSpace β] (h : HasCompactMulSupport f)
    (hf : Continuous f) : IsCompact (range f) 
goal: IsCompact (Set.range f)

full_name: HasCompactSupport.mono'
code: @[to_additive]
theorem mono' {f' : α → γ} (hf : HasCompactMulSupport f)
    (hff' : mulSupport f' ⊆ mulTSupport f) : HasCompactMulSupport f' 
goal: HasCompactSupport f'

full_name: HasCompactMulSupport.mono'
code: @[to_additive]
theorem mono' {f' : α → γ} (hf : HasCompactMulSupport f)
    (hff' : mulSupport f' ⊆ mulTSupport f) : HasCompactMulSupport f' 
goal: HasCompactMulSupport f'

full_name: HasCompactSupport.mono
code: @[to_additive]
theorem mono {f' : α → γ} (hf : HasCompactMulSupport f)
    (hff' : mulSupport f' ⊆ mulSupport f) : HasCompactMulSupport f' 
goal: HasCompactSupport f'

full_name: HasCompactMulSupport.mono
code: @[to_additive]
theorem mono {f' : α → γ} (hf : HasCompactMulSupport f)
    (hff' : mulSupport f' ⊆ mulSupport f) : HasCompactMulSupport f' 
goal: HasCompactMulSupport f'

full_name: HasCompactSupport.comp_left
code: @[to_additive]
theorem comp_left (hf : HasCompactMulSupport f) (hg : g 1 = 1) :
    HasCompactMulSupport (g ∘ f) 
goal: HasCompactSupport (g ∘ f)

full_name: HasCompactMulSupport.comp_left
code: @[to_additive]
theorem comp_left (hf : HasCompactMulSupport f) (hg : g 1 = 1) :
    HasCompactMulSupport (g ∘ f) 
goal: HasCompactMulSupport (g ∘ f)

full_name: hasCompactSupport_comp_left
code: @[to_additive]
theorem _root_.hasCompactMulSupport_comp_left (hg : ∀ {x}, g x = 1 ↔ x = 1) :
    HasCompactMulSupport (g ∘ f) ↔ HasCompactMulSupport f 
goal: HasCompactSupport (g ∘ f) ↔ HasCompactSupport f

full_name: hasCompactMulSupport_comp_left
code: @[to_additive]
theorem _root_.hasCompactMulSupport_comp_left (hg : ∀ {x}, g x = 1 ↔ x = 1) :
    HasCompactMulSupport (g ∘ f) ↔ HasCompactMulSupport f 
goal: HasCompactMulSupport (g ∘ f) ↔ HasCompactMulSupport f

full_name: HasCompactMulSupport.comp_closedEmbedding
code: @[to_additive]
theorem comp_closedEmbedding (hf : HasCompactMulSupport f) {g : α' → α}
    (hg : ClosedEmbedding g) : HasCompactMulSupport (f ∘ g) 
goal: HasCompactMulSupport (f ∘ g)

full_name: HasCompactSupport.comp_closedEmbedding
code: @[to_additive]
theorem comp_closedEmbedding (hf : HasCompactMulSupport f) {g : α' → α}
    (hg : ClosedEmbedding g) : HasCompactMulSupport (f ∘ g) 
goal: HasCompactSupport (f ∘ g)

full_name: HasCompactMulSupport.comp₂_left
code: @[to_additive]
theorem comp₂_left (hf : HasCompactMulSupport f)
    (hf₂ : HasCompactMulSupport f₂) (hm : m 1 1 = 1) :
    HasCompactMulSupport fun x => m (f x) (f₂ x) 
goal: HasCompactMulSupport fun x => m (f x) (f₂ x)

full_name: HasCompactSupport.comp₂_left
code: @[to_additive]
theorem comp₂_left (hf : HasCompactMulSupport f)
    (hf₂ : HasCompactMulSupport f₂) (hm : m 1 1 = 1) :
    HasCompactMulSupport fun x => m (f x) (f₂ x) 
goal: HasCompactSupport fun x => m (f x) (f₂ x)

full_name: HasCompactSupport.isCompact_preimage
code: @[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) 
goal: IsCompact (f ⁻¹' k)

full_name: HasCompactMulSupport.isCompact_preimage
code: @[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) 
goal: IsCompact (f ⁻¹' k)

full_name: HasCompactMulSupport.mulTSupport_extend_one_subset
code: @[to_additive]
theorem mulTSupport_extend_one_subset :
    mulTSupport (g.extend f 1) ⊆ g '' mulTSupport f 
goal: mulTSupport (Function.extend g f 1) ⊆ g '' mulTSupport f

full_name: HasCompactSupport.tsupport_extend_zero_subset
code: @[to_additive]
theorem mulTSupport_extend_one_subset :
    mulTSupport (g.extend f 1) ⊆ g '' mulTSupport f 
goal: tsupport (Function.extend g f 0) ⊆ g '' tsupport f

full_name: HasCompactSupport.extend_zero
code: @[to_additive]
theorem extend_one : HasCompactMulSupport (g.extend f 1) 
goal: HasCompactSupport (Function.extend g f 0)

full_name: HasCompactMulSupport.extend_one
code: @[to_additive]
theorem extend_one : HasCompactMulSupport (g.extend f 1) 
goal: HasCompactMulSupport (Function.extend g f 1)

full_name: HasCompactMulSupport.mulTSupport_extend_one
code: @[to_additive]
theorem mulTSupport_extend_one (inj : g.Injective) :
    mulTSupport (g.extend f 1) = g '' mulTSupport f 
goal: mulTSupport (Function.extend g f 1) = g '' mulTSupport f

full_name: HasCompactSupport.tsupport_extend_zero
code: @[to_additive]
theorem mulTSupport_extend_one (inj : g.Injective) :
    mulTSupport (g.extend f 1) = g '' mulTSupport f 
goal: tsupport (Function.extend g f 0) = g '' tsupport f

full_name: HasCompactSupport.continuous_extend_zero
code: @[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) 
goal: Continuous (Function.extend Subtype.val f 0)

full_name: HasCompactMulSupport.continuous_extend_one
code: @[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) 
goal: Continuous (Function.extend Subtype.val f 1)

full_name: HasCompactMulSupport.is_one_at_infty
code: /-- If `f` has compact multiplicative support, then `f` tends to 1 at infinity. -/
@[to_additive "If `f` has compact support, then `f` tends to zero at infinity."]
theorem is_one_at_infty {f : α → γ} [TopologicalSpace γ] [One γ]
    (h : HasCompactMulSupport f) : Tendsto f (cocompact α) (𝓝 1) 
goal: Filter.Tendsto f (Filter.cocompact α) (𝓝 1)

full_name: HasCompactSupport.is_zero_at_infty
code: /-- If `f` has compact multiplicative support, then `f` tends to 1 at infinity. -/
@[to_additive "If `f` has compact support, then `f` tends to zero at infinity."]
theorem is_one_at_infty {f : α → γ} [TopologicalSpace γ] [One γ]
    (h : HasCompactMulSupport f) : Tendsto f (cocompact α) (𝓝 1) 
goal: Filter.Tendsto f (Filter.cocompact α) (𝓝 0)

full_name: HasCompactSupport.of_compactSpace
code: /-- In a compact space `α`, any function has compact support. -/
@[to_additive]
theorem HasCompactMulSupport.of_compactSpace (f : α → γ) :
    HasCompactMulSupport f 
goal: HasCompactSupport f

full_name: HasCompactMulSupport.of_compactSpace
code: /-- In a compact space `α`, any function has compact support. -/
@[to_additive]
theorem HasCompactMulSupport.of_compactSpace (f : α → γ) :
    HasCompactMulSupport f 
goal: HasCompactMulSupport f

full_name: HasCompactSupport.add
code: @[to_additive]
theorem HasCompactMulSupport.mul (hf : HasCompactMulSupport f) (hf' : HasCompactMulSupport f') :
    HasCompactMulSupport (f * f') 
goal: HasCompactSupport (f + f')

full_name: HasCompactMulSupport.mul
code: @[to_additive]
theorem HasCompactMulSupport.mul (hf : HasCompactMulSupport f) (hf' : HasCompactMulSupport f') :
    HasCompactMulSupport (f * f') 
goal: HasCompactMulSupport (f * f')

full_name: HasCompactSupport.smul_left
code: theorem HasCompactSupport.smul_left (hf : HasCompactSupport f') : HasCompactSupport (f • f') 
goal: HasCompactSupport (f • f')

full_name: HasCompactSupport.smul_right
code: theorem HasCompactSupport.smul_right (hf : HasCompactSupport f) : HasCompactSupport (f • f') 
goal: HasCompactSupport (f • f')

full_name: HasCompactSupport.mul_right
code: theorem HasCompactSupport.mul_right (hf : HasCompactSupport f) : HasCompactSupport (f * f') 
goal: HasCompactSupport (f * f')

full_name: HasCompactSupport.mul_left
code: theorem HasCompactSupport.mul_left (hf : HasCompactSupport f') : HasCompactSupport (f * f') 
goal: HasCompactSupport (f * f')

full_name: HasCompactSupport.abs
code: protected theorem HasCompactSupport.abs {f : α → β} (hf : HasCompactSupport f) :
    HasCompactSupport |f| 
goal: HasCompactSupport |f|

full_name: LocallyFinite.exists_finset_nhd_support_subset
code: /-- 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. -/
@[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 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) ∧
      ∀ z ∈ n, (mulSupport fun i => f i z) ⊆ is 
goal: ∃ is, ∃ n ∈ 𝓝 x, n ⊆ ⋂ i ∈ is, U i ∧ ∀ z ∈ n, (Function.support fun i => f i z) ⊆ ↑is

full_name: LocallyFinite.exists_finset_nhd_mulSupport_subset
code: /-- 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. -/
@[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 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) ∧
      ∀ z ∈ n, (mulSupport fun i => f i z) ⊆ is 
goal: ∃ is, ∃ n ∈ 𝓝 x, n ⊆ ⋂ i ∈ is, U i ∧ ∀ z ∈ n, (Function.mulSupport fun i => f i z) ⊆ ↑is

full_name: locallyFinite_support_iff
code: @[to_additive]
theorem locallyFinite_mulSupport_iff [CommMonoid M] {f : ι → X → M} :
    (LocallyFinite fun i ↦ mulSupport <| f i) ↔ LocallyFinite fun i ↦ mulTSupport <| f i 
goal: (LocallyFinite fun i => Function.support (f i)) ↔ LocallyFinite fun i => tsupport (f i)

full_name: locallyFinite_mulSupport_iff
code: @[to_additive]
theorem locallyFinite_mulSupport_iff [CommMonoid M] {f : ι → X → M} :
    (LocallyFinite fun i ↦ mulSupport <| f i) ↔ LocallyFinite fun i ↦ mulTSupport <| f i 
goal: (LocallyFinite fun i => Function.mulSupport (f i)) ↔ LocallyFinite fun i => mulTSupport (f i)

full_name: LocallyFinite.smul_left
code: 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 
goal: LocallyFinite fun i => Function.support (s i • f i)

full_name: LocallyFinite.smul_right
code: 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 
goal: LocallyFinite fun i => Function.support (s i • f i)