File: Mathlib/Algebra/Group/Support.lean

full_name: Function.mulSupport
code: /-- `mulSupport` of a function is the set of points `x` such that `f x ≠ 1`. -/
@[to_additive "`support` of a function is the set of points `x` such that `f x ≠ 0`."]
def mulSupport (f : α → M) : Set α 
goal: Set α

full_name: Function.support
code: /-- `mulSupport` of a function is the set of points `x` such that `f x ≠ 1`. -/
@[to_additive "`support` of a function is the set of points `x` such that `f x ≠ 0`."]
def mulSupport (f : α → M) : Set α 
goal: Set α

full_name: Function.mulSupport_eq_preimage
code: @[to_additive]
theorem mulSupport_eq_preimage (f : α → M) : mulSupport f = f ⁻¹' {1}ᶜ 
goal: Function.mulSupport f = f ⁻¹' {1}ᶜ

full_name: Function.support_eq_preimage
code: @[to_additive]
theorem mulSupport_eq_preimage (f : α → M) : mulSupport f = f ⁻¹' {1}ᶜ 
goal: Function.support f = f ⁻¹' {0}ᶜ

full_name: Function.nmem_mulSupport
code: @[to_additive]
theorem nmem_mulSupport {f : α → M} {x : α} : x ∉ mulSupport f ↔ f x = 1 
goal: x ∉ Function.mulSupport f ↔ f x = 1

full_name: Function.nmem_support
code: @[to_additive]
theorem nmem_mulSupport {f : α → M} {x : α} : x ∉ mulSupport f ↔ f x = 1 
goal: x ∉ Function.support f ↔ f x = 0

full_name: Function.compl_mulSupport
code: @[to_additive]
theorem compl_mulSupport {f : α → M} : (mulSupport f)ᶜ = { x | f x = 1 } 
goal: (Function.mulSupport f)ᶜ = {x | f x = 1}

full_name: Function.compl_support
code: @[to_additive]
theorem compl_mulSupport {f : α → M} : (mulSupport f)ᶜ = { x | f x = 1 } 
goal: (Function.support f)ᶜ = {x | f x = 0}

full_name: Function.mem_mulSupport
code: @[to_additive (attr := simp)]
theorem mem_mulSupport {f : α → M} {x : α} : x ∈ mulSupport f ↔ f x ≠ 1 
goal: x ∈ Function.mulSupport f ↔ f x ≠ 1

full_name: Function.mem_support
code: @[to_additive (attr := simp)]
theorem mem_mulSupport {f : α → M} {x : α} : x ∈ mulSupport f ↔ f x ≠ 1 
goal: x ∈ Function.support f ↔ f x ≠ 0

full_name: Function.mulSupport_subset_iff
code: @[to_additive (attr := simp)]
theorem mulSupport_subset_iff {f : α → M} {s : Set α} : mulSupport f ⊆ s ↔ ∀ x, f x ≠ 1 → x ∈ s 
goal: Function.mulSupport f ⊆ s ↔ ∀ (x : α), f x ≠ 1 → x ∈ s

full_name: Function.support_subset_iff
code: @[to_additive (attr := simp)]
theorem mulSupport_subset_iff {f : α → M} {s : Set α} : mulSupport f ⊆ s ↔ ∀ x, f x ≠ 1 → x ∈ s 
goal: Function.support f ⊆ s ↔ ∀ (x : α), f x ≠ 0 → x ∈ s

full_name: Function.support_subset_iff'
code: @[to_additive]
theorem mulSupport_subset_iff' {f : α → M} {s : Set α} :
    mulSupport f ⊆ s ↔ ∀ x ∉ s, f x = 1 
goal: Function.support f ⊆ s ↔ ∀ x ∉ s, f x = 0

full_name: Function.mulSupport_subset_iff'
code: @[to_additive]
theorem mulSupport_subset_iff' {f : α → M} {s : Set α} :
    mulSupport f ⊆ s ↔ ∀ x ∉ s, f x = 1 
goal: Function.mulSupport f ⊆ s ↔ ∀ x ∉ s, f x = 1

full_name: Function.mulSupport_eq_iff
code: @[to_additive]
theorem mulSupport_eq_iff {f : α → M} {s : Set α} :
    mulSupport f = s ↔ (∀ x, x ∈ s → f x ≠ 1) ∧ ∀ x, x ∉ s → f x = 1 
goal: Function.mulSupport f = s ↔ (∀ x ∈ s, f x ≠ 1) ∧ ∀ x ∉ s, f x = 1

full_name: Function.support_eq_iff
code: @[to_additive]
theorem mulSupport_eq_iff {f : α → M} {s : Set α} :
    mulSupport f = s ↔ (∀ x, x ∈ s → f x ≠ 1) ∧ ∀ x, x ∉ s → f x = 1 
goal: Function.support f = s ↔ (∀ x ∈ s, f x ≠ 0) ∧ ∀ x ∉ s, f x = 0

full_name: Function.ext_iff_mulSupport
code: @[to_additive]
theorem ext_iff_mulSupport {f g : α → M} :
    f = g ↔ f.mulSupport = g.mulSupport ∧ ∀ x ∈ f.mulSupport, f x = g x 
goal: f = g ↔ Function.mulSupport f = Function.mulSupport g ∧ ∀ x ∈ Function.mulSupport f, f x = g x

full_name: Function.ext_iff_support
code: @[to_additive]
theorem ext_iff_mulSupport {f g : α → M} :
    f = g ↔ f.mulSupport = g.mulSupport ∧ ∀ x ∈ f.mulSupport, f x = g x 
goal: f = g ↔ Function.support f = Function.support g ∧ ∀ x ∈ Function.support f, f x = g x

full_name: Function.mulSupport_update_of_ne_one
code: @[to_additive]
theorem mulSupport_update_of_ne_one [DecidableEq α] (f : α → M) (x : α) {y : M} (hy : y ≠ 1) :
    mulSupport (update f x y) = insert x (mulSupport f) 
goal: Function.mulSupport (Function.update f x y) = insert x (Function.mulSupport f)

full_name: Function.support_update_of_ne_zero
code: @[to_additive]
theorem mulSupport_update_of_ne_one [DecidableEq α] (f : α → M) (x : α) {y : M} (hy : y ≠ 1) :
    mulSupport (update f x y) = insert x (mulSupport f) 
goal: Function.support (Function.update f x y) = insert x (Function.support f)

full_name: Function.support_update_zero
code: @[to_additive]
theorem mulSupport_update_one [DecidableEq α] (f : α → M) (x : α) :
    mulSupport (update f x 1) = mulSupport f \ {x} 
goal: Function.support (Function.update f x 0) = Function.support f \ {x}

full_name: Function.mulSupport_update_one
code: @[to_additive]
theorem mulSupport_update_one [DecidableEq α] (f : α → M) (x : α) :
    mulSupport (update f x 1) = mulSupport f \ {x} 
goal: Function.mulSupport (Function.update f x 1) = Function.mulSupport f \ {x}

full_name: Function.mulSupport_update_eq_ite
code: @[to_additive]
theorem mulSupport_update_eq_ite [DecidableEq α] [DecidableEq M] (f : α → M) (x : α) (y : M) :
    mulSupport (update f x y) = if y = 1 then mulSupport f \ {x} else insert x (mulSupport f) 
goal: Function.mulSupport (Function.update f x y) =
  if y = 1 then Function.mulSupport f \ {x} else insert x (Function.mulSupport f)

full_name: Function.support_update_eq_ite
code: @[to_additive]
theorem mulSupport_update_eq_ite [DecidableEq α] [DecidableEq M] (f : α → M) (x : α) (y : M) :
    mulSupport (update f x y) = if y = 1 then mulSupport f \ {x} else insert x (mulSupport f) 
goal: Function.support (Function.update f x y) = if y = 0 then Function.support f \ {x} else insert x (Function.support f)

full_name: Function.support_extend_zero_subset
code: @[to_additive]
theorem mulSupport_extend_one_subset {f : α → M'} {g : α → N} :
    mulSupport (f.extend g 1) ⊆ f '' mulSupport g 
goal: Function.support (Function.extend f g 0) ⊆ f '' Function.support g

full_name: Function.mulSupport_extend_one_subset
code: @[to_additive]
theorem mulSupport_extend_one_subset {f : α → M'} {g : α → N} :
    mulSupport (f.extend g 1) ⊆ f '' mulSupport g 
goal: Function.mulSupport (Function.extend f g 1) ⊆ f '' Function.mulSupport g

full_name: Function.mulSupport_extend_one
code: @[to_additive]
theorem mulSupport_extend_one {f : α → M'} {g : α → N} (hf : f.Injective) :
    mulSupport (f.extend g 1) = f '' mulSupport g 
goal: Function.mulSupport (Function.extend f g 1) = f '' Function.mulSupport g

full_name: Function.support_extend_zero
code: @[to_additive]
theorem mulSupport_extend_one {f : α → M'} {g : α → N} (hf : f.Injective) :
    mulSupport (f.extend g 1) = f '' mulSupport g 
goal: Function.support (Function.extend f g 0) = f '' Function.support g

full_name: Function.support_disjoint_iff
code: @[to_additive]
theorem mulSupport_disjoint_iff {f : α → M} {s : Set α} :
    Disjoint (mulSupport f) s ↔ EqOn f 1 s 
goal: Disjoint (Function.support f) s ↔ Set.EqOn f 0 s

full_name: Function.mulSupport_disjoint_iff
code: @[to_additive]
theorem mulSupport_disjoint_iff {f : α → M} {s : Set α} :
    Disjoint (mulSupport f) s ↔ EqOn f 1 s 
goal: Disjoint (Function.mulSupport f) s ↔ Set.EqOn f 1 s

full_name: Function.disjoint_support_iff
code: @[to_additive]
theorem disjoint_mulSupport_iff {f : α → M} {s : Set α} :
    Disjoint s (mulSupport f) ↔ EqOn f 1 s 
goal: Disjoint s (Function.support f) ↔ Set.EqOn f 0 s

full_name: Function.disjoint_mulSupport_iff
code: @[to_additive]
theorem disjoint_mulSupport_iff {f : α → M} {s : Set α} :
    Disjoint s (mulSupport f) ↔ EqOn f 1 s 
goal: Disjoint s (Function.mulSupport f) ↔ Set.EqOn f 1 s

full_name: Function.support_eq_empty_iff
code: @[to_additive (attr := simp)]
theorem mulSupport_eq_empty_iff {f : α → M} : mulSupport f = ∅ ↔ f = 1 
goal: Function.support f = ∅ ↔ f = 0

full_name: Function.mulSupport_eq_empty_iff
code: @[to_additive (attr := simp)]
theorem mulSupport_eq_empty_iff {f : α → M} : mulSupport f = ∅ ↔ f = 1 
goal: Function.mulSupport f = ∅ ↔ f = 1

full_name: Function.support_nonempty_iff
code: @[to_additive (attr := simp)]
theorem mulSupport_nonempty_iff {f : α → M} : (mulSupport f).Nonempty ↔ f ≠ 1 
goal: (Function.support f).Nonempty ↔ f ≠ 0

full_name: Function.mulSupport_nonempty_iff
code: @[to_additive (attr := simp)]
theorem mulSupport_nonempty_iff {f : α → M} : (mulSupport f).Nonempty ↔ f ≠ 1 
goal: (Function.mulSupport f).Nonempty ↔ f ≠ 1

full_name: Function.range_subset_insert_image_mulSupport
code: @[to_additive]
theorem range_subset_insert_image_mulSupport (f : α → M) :
    range f ⊆ insert 1 (f '' mulSupport f) 
goal: Set.range f ⊆ insert 1 (f '' Function.mulSupport f)

full_name: Function.range_subset_insert_image_support
code: @[to_additive]
theorem range_subset_insert_image_mulSupport (f : α → M) :
    range f ⊆ insert 1 (f '' mulSupport f) 
goal: Set.range f ⊆ insert 0 (f '' Function.support f)

full_name: Function.range_eq_image_or_of_mulSupport_subset
code: @[to_additive]
lemma range_eq_image_or_of_mulSupport_subset {f : α → M} {k : Set α} (h : mulSupport f ⊆ k) :
    range f = f '' k ∨ range f = insert 1 (f '' k) 
goal: Set.range f = f '' k ∨ Set.range f = insert 1 (f '' k)

full_name: Function.range_eq_image_or_of_support_subset
code: @[to_additive]
lemma range_eq_image_or_of_mulSupport_subset {f : α → M} {k : Set α} (h : mulSupport f ⊆ k) :
    range f = f '' k ∨ range f = insert 1 (f '' k) 
goal: Set.range f = f '' k ∨ Set.range f = insert 0 (f '' k)

full_name: Function.mulSupport_one'
code: @[to_additive (attr := simp)]
theorem mulSupport_one' : mulSupport (1 : α → M) = ∅ 
goal: Function.mulSupport 1 = ∅

full_name: Function.support_zero'
code: @[to_additive (attr := simp)]
theorem mulSupport_one' : mulSupport (1 : α → M) = ∅ 
goal: Function.support 0 = ∅

full_name: Function.mulSupport_one
code: @[to_additive (attr := simp)]
theorem mulSupport_one : (mulSupport fun _ : α => (1 : M)) = ∅ 
goal: (Function.mulSupport fun x => 1) = ∅

full_name: Function.support_zero
code: @[to_additive (attr := simp)]
theorem mulSupport_one : (mulSupport fun _ : α => (1 : M)) = ∅ 
goal: (Function.support fun x => 0) = ∅

full_name: Function.support_const
code: @[to_additive]
theorem mulSupport_const {c : M} (hc : c ≠ 1) : (mulSupport fun _ : α => c) = Set.univ 
goal: (Function.support fun x => c) = Set.univ

full_name: Function.mulSupport_const
code: @[to_additive]
theorem mulSupport_const {c : M} (hc : c ≠ 1) : (mulSupport fun _ : α => c) = Set.univ 
goal: (Function.mulSupport fun x => c) = Set.univ

full_name: Function.support_binop_subset
code: @[to_additive]
theorem mulSupport_binop_subset (op : M → N → P) (op1 : op 1 1 = 1) (f : α → M) (g : α → N) :
    (mulSupport fun x => op (f x) (g x)) ⊆ mulSupport f ∪ mulSupport g 
goal: (Function.support fun x => op (f x) (g x)) ⊆ Function.support f ∪ Function.support g

full_name: Function.mulSupport_binop_subset
code: @[to_additive]
theorem mulSupport_binop_subset (op : M → N → P) (op1 : op 1 1 = 1) (f : α → M) (g : α → N) :
    (mulSupport fun x => op (f x) (g x)) ⊆ mulSupport f ∪ mulSupport g 
goal: (Function.mulSupport fun x => op (f x) (g x)) ⊆ Function.mulSupport f ∪ Function.mulSupport g

full_name: Function.mulSupport_comp_subset
code: @[to_additive]
theorem mulSupport_comp_subset {g : M → N} (hg : g 1 = 1) (f : α → M) :
    mulSupport (g ∘ f) ⊆ mulSupport f 
goal: Function.mulSupport (g ∘ f) ⊆ Function.mulSupport f

full_name: Function.support_comp_subset
code: @[to_additive]
theorem mulSupport_comp_subset {g : M → N} (hg : g 1 = 1) (f : α → M) :
    mulSupport (g ∘ f) ⊆ mulSupport f 
goal: Function.support (g ∘ f) ⊆ Function.support f

full_name: Function.support_subset_comp
code: @[to_additive]
theorem mulSupport_subset_comp {g : M → N} (hg : ∀ {x}, g x = 1 → x = 1) (f : α → M) :
    mulSupport f ⊆ mulSupport (g ∘ f) 
goal: Function.support f ⊆ Function.support (g ∘ f)

full_name: Function.mulSupport_subset_comp
code: @[to_additive]
theorem mulSupport_subset_comp {g : M → N} (hg : ∀ {x}, g x = 1 → x = 1) (f : α → M) :
    mulSupport f ⊆ mulSupport (g ∘ f) 
goal: Function.mulSupport f ⊆ Function.mulSupport (g ∘ f)

full_name: Function.mulSupport_comp_eq
code: @[to_additive]
theorem mulSupport_comp_eq (g : M → N) (hg : ∀ {x}, g x = 1 ↔ x = 1) (f : α → M) :
    mulSupport (g ∘ f) = mulSupport f 
goal: Function.mulSupport (g ∘ f) = Function.mulSupport f

full_name: Function.support_comp_eq
code: @[to_additive]
theorem mulSupport_comp_eq (g : M → N) (hg : ∀ {x}, g x = 1 ↔ x = 1) (f : α → M) :
    mulSupport (g ∘ f) = mulSupport f 
goal: Function.support (g ∘ f) = Function.support f

full_name: Function.mulSupport_comp_eq_of_range_subset
code: @[to_additive]
theorem mulSupport_comp_eq_of_range_subset {g : M → N} {f : α → M}
    (hg : ∀ {x}, x ∈ range f → (g x = 1 ↔ x = 1)) :
    mulSupport (g ∘ f) = mulSupport f 
goal: Function.mulSupport (g ∘ f) = Function.mulSupport f

full_name: Function.support_comp_eq_of_range_subset
code: @[to_additive]
theorem mulSupport_comp_eq_of_range_subset {g : M → N} {f : α → M}
    (hg : ∀ {x}, x ∈ range f → (g x = 1 ↔ x = 1)) :
    mulSupport (g ∘ f) = mulSupport f 
goal: Function.support (g ∘ f) = Function.support f

full_name: Function.mulSupport_comp_eq_preimage
code: @[to_additive]
theorem mulSupport_comp_eq_preimage (g : β → M) (f : α → β) :
    mulSupport (g ∘ f) = f ⁻¹' mulSupport g 
goal: Function.mulSupport (g ∘ f) = f ⁻¹' Function.mulSupport g

full_name: Function.support_comp_eq_preimage
code: @[to_additive]
theorem mulSupport_comp_eq_preimage (g : β → M) (f : α → β) :
    mulSupport (g ∘ f) = f ⁻¹' mulSupport g 
goal: Function.support (g ∘ f) = f ⁻¹' Function.support g

full_name: Function.support_prod_mk
code: @[to_additive support_prod_mk]
theorem mulSupport_prod_mk (f : α → M) (g : α → N) :
    (mulSupport fun x => (f x, g x)) = mulSupport f ∪ mulSupport g 
goal: (Function.support fun x => (f x, g x)) = Function.support f ∪ Function.support g

full_name: Function.mulSupport_prod_mk
code: @[to_additive support_prod_mk]
theorem mulSupport_prod_mk (f : α → M) (g : α → N) :
    (mulSupport fun x => (f x, g x)) = mulSupport f ∪ mulSupport g 
goal: (Function.mulSupport fun x => (f x, g x)) = Function.mulSupport f ∪ Function.mulSupport g

full_name: Function.support_prod_mk'
code: @[to_additive support_prod_mk']
theorem mulSupport_prod_mk' (f : α → M × N) :
    mulSupport f = (mulSupport fun x => (f x).1) ∪ mulSupport fun x => (f x).2 
goal: Function.support f = (Function.support fun x => (f x).1) ∪ Function.support fun x => (f x).2

full_name: Function.mulSupport_prod_mk'
code: @[to_additive support_prod_mk']
theorem mulSupport_prod_mk' (f : α → M × N) :
    mulSupport f = (mulSupport fun x => (f x).1) ∪ mulSupport fun x => (f x).2 
goal: Function.mulSupport f = (Function.mulSupport fun x => (f x).1) ∪ Function.mulSupport fun x => (f x).2

full_name: Function.mulSupport_along_fiber_subset
code: @[to_additive]
theorem mulSupport_along_fiber_subset (f : α × β → M) (a : α) :
    (mulSupport fun b => f (a, b)) ⊆ (mulSupport f).image Prod.snd 
goal: (Function.mulSupport fun b => f (a, b)) ⊆ Prod.snd '' Function.mulSupport f

full_name: Function.support_along_fiber_subset
code: @[to_additive]
theorem mulSupport_along_fiber_subset (f : α × β → M) (a : α) :
    (mulSupport fun b => f (a, b)) ⊆ (mulSupport f).image Prod.snd 
goal: (Function.support fun b => f (a, b)) ⊆ Prod.snd '' Function.support f

full_name: Function.mulSupport_curry
code: @[to_additive]
theorem mulSupport_curry (f : α × β → M) :
    (mulSupport f.curry) = (mulSupport f).image Prod.fst 
goal: Function.mulSupport (Function.curry f) = Prod.fst '' Function.mulSupport f

full_name: Function.support_curry
code: @[to_additive]
theorem mulSupport_curry (f : α × β → M) :
    (mulSupport f.curry) = (mulSupport f).image Prod.fst 
goal: Function.support (Function.curry f) = Prod.fst '' Function.support f

full_name: Function.mulSupport_curry'
code: @[to_additive]
theorem mulSupport_curry' (f : α × β → M) :
    (mulSupport fun a b ↦ f (a, b)) = (mulSupport f).image Prod.fst 
goal: (Function.mulSupport fun a b => f (a, b)) = Prod.fst '' Function.mulSupport f

full_name: Function.support_curry'
code: @[to_additive]
theorem mulSupport_curry' (f : α × β → M) :
    (mulSupport fun a b ↦ f (a, b)) = (mulSupport f).image Prod.fst 
goal: (Function.support fun a b => f (a, b)) = Prod.fst '' Function.support f

full_name: Function.support_add
code: @[to_additive]
theorem mulSupport_mul [MulOneClass M] (f g : α → M) :
    (mulSupport fun x => f x * g x) ⊆ mulSupport f ∪ mulSupport g 
goal: (Function.support fun x => f x + g x) ⊆ Function.support f ∪ Function.support g

full_name: Function.mulSupport_mul
code: @[to_additive]
theorem mulSupport_mul [MulOneClass M] (f g : α → M) :
    (mulSupport fun x => f x * g x) ⊆ mulSupport f ∪ mulSupport g 
goal: (Function.mulSupport fun x => f x * g x) ⊆ Function.mulSupport f ∪ Function.mulSupport g

full_name: Function.support_nsmul
code: @[to_additive]
theorem mulSupport_pow [Monoid M] (f : α → M) (n : ℕ) :
    (mulSupport fun x => f x ^ n) ⊆ mulSupport f 
goal: (Function.support fun x => n • f x) ⊆ Function.support f

full_name: Function.mulSupport_pow
code: @[to_additive]
theorem mulSupport_pow [Monoid M] (f : α → M) (n : ℕ) :
    (mulSupport fun x => f x ^ n) ⊆ mulSupport f 
goal: (Function.mulSupport fun x => f x ^ n) ⊆ Function.mulSupport f

full_name: Function.support_neg
code: @[to_additive (attr := simp)]
theorem mulSupport_inv : (mulSupport fun x => (f x)⁻¹) = mulSupport f 
goal: (Function.support fun x => -f x) = Function.support f

full_name: Function.mulSupport_inv
code: @[to_additive (attr := simp)]
theorem mulSupport_inv : (mulSupport fun x => (f x)⁻¹) = mulSupport f 
goal: (Function.mulSupport fun x => (f x)⁻¹) = Function.mulSupport f

full_name: Function.mulSupport_inv'
code: @[to_additive (attr := simp)]
theorem mulSupport_inv' : mulSupport f⁻¹ = mulSupport f 
goal: Function.mulSupport f⁻¹ = Function.mulSupport f

full_name: Function.support_neg'
code: @[to_additive (attr := simp)]
theorem mulSupport_inv' : mulSupport f⁻¹ = mulSupport f 
goal: Function.support (-f) = Function.support f

full_name: Function.mulSupport_mul_inv
code: @[to_additive]
theorem mulSupport_mul_inv : (mulSupport fun x => f x * (g x)⁻¹) ⊆ mulSupport f ∪ mulSupport g 
goal: (Function.mulSupport fun x => f x * (g x)⁻¹) ⊆ Function.mulSupport f ∪ Function.mulSupport g

full_name: Function.support_add_neg
code: @[to_additive]
theorem mulSupport_mul_inv : (mulSupport fun x => f x * (g x)⁻¹) ⊆ mulSupport f ∪ mulSupport g 
goal: (Function.support fun x => f x + -g x) ⊆ Function.support f ∪ Function.support g

full_name: Function.mulSupport_div
code: @[to_additive]
theorem mulSupport_div : (mulSupport fun x => f x / g x) ⊆ mulSupport f ∪ mulSupport g 
goal: (Function.mulSupport fun x => f x / g x) ⊆ Function.mulSupport f ∪ Function.mulSupport g

full_name: Function.support_sub
code: @[to_additive]
theorem mulSupport_div : (mulSupport fun x => f x / g x) ⊆ mulSupport f ∪ mulSupport g 
goal: (Function.support fun x => f x - g x) ⊆ Function.support f ∪ Function.support g

full_name: Set.image_inter_support_eq
code: @[to_additive]
theorem image_inter_mulSupport_eq {s : Set β} {g : β → α} :
    g '' s ∩ mulSupport f = g '' (s ∩ mulSupport (f ∘ g)) 
goal: g '' s ∩ Function.support f = g '' (s ∩ Function.support (f ∘ g))

full_name: Set.image_inter_mulSupport_eq
code: @[to_additive]
theorem image_inter_mulSupport_eq {s : Set β} {g : β → α} :
    g '' s ∩ mulSupport f = g '' (s ∩ mulSupport (f ∘ g)) 
goal: g '' s ∩ Function.mulSupport f = g '' (s ∩ Function.mulSupport (f ∘ g))

full_name: Pi.support_single_subset
code: @[to_additive]
theorem mulSupport_mulSingle_subset : mulSupport (mulSingle a b) ⊆ {a} 
goal: Function.support (Pi.single a b) ⊆ {a}

full_name: Pi.mulSupport_mulSingle_subset
code: @[to_additive]
theorem mulSupport_mulSingle_subset : mulSupport (mulSingle a b) ⊆ {a} 
goal: Function.mulSupport (Pi.mulSingle a b) ⊆ {a}

full_name: Pi.mulSupport_mulSingle_one
code: @[to_additive]
theorem mulSupport_mulSingle_one : mulSupport (mulSingle a (1 : B)) = ∅ 
goal: Function.mulSupport (Pi.mulSingle a 1) = ∅

full_name: Pi.support_single_zero
code: @[to_additive]
theorem mulSupport_mulSingle_one : mulSupport (mulSingle a (1 : B)) = ∅ 
goal: Function.support (Pi.single a 0) = ∅

full_name: Pi.mulSupport_mulSingle_of_ne
code: @[to_additive (attr := simp)]
theorem mulSupport_mulSingle_of_ne (h : b ≠ 1) : mulSupport (mulSingle a b) = {a} 
goal: Function.mulSupport (Pi.mulSingle a b) = {a}

full_name: Pi.support_single_of_ne
code: @[to_additive (attr := simp)]
theorem mulSupport_mulSingle_of_ne (h : b ≠ 1) : mulSupport (mulSingle a b) = {a} 
goal: Function.support (Pi.single a b) = {a}

full_name: Pi.mulSupport_mulSingle
code: @[to_additive]
theorem mulSupport_mulSingle [DecidableEq B] :
    mulSupport (mulSingle a b) = if b = 1 then ∅ else {a} 
goal: Function.mulSupport (Pi.mulSingle a b) = if b = 1 then ∅ else {a}

full_name: Pi.support_single
code: @[to_additive]
theorem mulSupport_mulSingle [DecidableEq B] :
    mulSupport (mulSingle a b) = if b = 1 then ∅ else {a} 
goal: Function.support (Pi.single a b) = if b = 0 then ∅ else {a}

full_name: Pi.support_single_disjoint
code: @[to_additive]
theorem mulSupport_mulSingle_disjoint {b' : B} (hb : b ≠ 1) (hb' : b' ≠ 1) {i j : A} :
    Disjoint (mulSupport (mulSingle i b)) (mulSupport (mulSingle j b')) ↔ i ≠ j 
goal: Disjoint (Function.support (Pi.single i b)) (Function.support (Pi.single j b')) ↔ i ≠ j

full_name: Pi.mulSupport_mulSingle_disjoint
code: @[to_additive]
theorem mulSupport_mulSingle_disjoint {b' : B} (hb : b ≠ 1) (hb' : b' ≠ 1) {i j : A} :
    Disjoint (mulSupport (mulSingle i b)) (mulSupport (mulSingle j b')) ↔ i ≠ j 
goal: Disjoint (Function.mulSupport (Pi.mulSingle i b)) (Function.mulSupport (Pi.mulSingle j b')) ↔ i ≠ j