File: Mathlib/Algebra/Group/Indicator.lean

full_name: Set.indicator
code: /-- `Set.mulIndicator s f a` is `f a` if `a ∈ s`, `1` otherwise.  -/
@[to_additive "`Set.indicator s f a` is `f a` if `a ∈ s`, `0` otherwise."]
noncomputable def mulIndicator (s : Set α) (f : α → M) (x : α) : M 
goal: M

full_name: Set.mulIndicator
code: /-- `Set.mulIndicator s f a` is `f a` if `a ∈ s`, `1` otherwise.  -/
@[to_additive "`Set.indicator s f a` is `f a` if `a ∈ s`, `0` otherwise."]
noncomputable def mulIndicator (s : Set α) (f : α → M) (x : α) : M 
goal: M

full_name: Set.piecewise_eq_indicator
code: @[to_additive (attr := simp)]
theorem piecewise_eq_mulIndicator [DecidablePred (· ∈ s)] : s.piecewise f 1 = s.mulIndicator f 
goal: s.piecewise f 0 = s.indicator f

full_name: Set.piecewise_eq_mulIndicator
code: @[to_additive (attr := simp)]
theorem piecewise_eq_mulIndicator [DecidablePred (· ∈ s)] : s.piecewise f 1 = s.mulIndicator f 
goal: s.piecewise f 1 = s.mulIndicator f

full_name: Set.mulIndicator_apply
code: @[to_additive]
theorem mulIndicator_apply (s : Set α) (f : α → M) (a : α) [Decidable (a ∈ s)] :
    mulIndicator s f a = if a ∈ s then f a else 1 
goal: s.mulIndicator f a = if a ∈ s then f a else 1

full_name: Set.indicator_apply
code: @[to_additive]
theorem mulIndicator_apply (s : Set α) (f : α → M) (a : α) [Decidable (a ∈ s)] :
    mulIndicator s f a = if a ∈ s then f a else 1 
goal: s.indicator f a = if a ∈ s then f a else 0

full_name: Set.indicator_of_mem
code: @[to_additive (attr := simp)]
theorem mulIndicator_of_mem (h : a ∈ s) (f : α → M) : mulIndicator s f a = f a 
goal: s.indicator f a = f a

full_name: Set.mulIndicator_of_mem
code: @[to_additive (attr := simp)]
theorem mulIndicator_of_mem (h : a ∈ s) (f : α → M) : mulIndicator s f a = f a 
goal: s.mulIndicator f a = f a

full_name: Set.indicator_of_not_mem
code: @[to_additive (attr := simp)]
theorem mulIndicator_of_not_mem (h : a ∉ s) (f : α → M) : mulIndicator s f a = 1 
goal: s.indicator f a = 0

full_name: Set.mulIndicator_of_not_mem
code: @[to_additive (attr := simp)]
theorem mulIndicator_of_not_mem (h : a ∉ s) (f : α → M) : mulIndicator s f a = 1 
goal: s.mulIndicator f a = 1

full_name: Set.mulIndicator_eq_one_or_self
code: @[to_additive]
theorem mulIndicator_eq_one_or_self (s : Set α) (f : α → M) (a : α) :
    mulIndicator s f a = 1 ∨ mulIndicator s f a = f a 
goal: s.mulIndicator f a = 1 ∨ s.mulIndicator f a = f a

full_name: Set.indicator_eq_zero_or_self
code: @[to_additive]
theorem mulIndicator_eq_one_or_self (s : Set α) (f : α → M) (a : α) :
    mulIndicator s f a = 1 ∨ mulIndicator s f a = f a 
goal: s.indicator f a = 0 ∨ s.indicator f a = f a

full_name: Set.indicator_apply_eq_self
code: @[to_additive (attr := simp)]
theorem mulIndicator_apply_eq_self : s.mulIndicator f a = f a ↔ a ∉ s → f a = 1 
goal: s.indicator f a = f a ↔ a ∉ s → f a = 0

full_name: Set.mulIndicator_apply_eq_self
code: @[to_additive (attr := simp)]
theorem mulIndicator_apply_eq_self : s.mulIndicator f a = f a ↔ a ∉ s → f a = 1 
goal: s.mulIndicator f a = f a ↔ a ∉ s → f a = 1

full_name: Set.indicator_eq_self
code: @[to_additive (attr := simp)]
theorem mulIndicator_eq_self : s.mulIndicator f = f ↔ mulSupport f ⊆ s 
goal: s.indicator f = f ↔ Function.support f ⊆ s

full_name: Set.mulIndicator_eq_self
code: @[to_additive (attr := simp)]
theorem mulIndicator_eq_self : s.mulIndicator f = f ↔ mulSupport f ⊆ s 
goal: s.mulIndicator f = f ↔ Function.mulSupport f ⊆ s

full_name: Set.indicator_eq_self_of_superset
code: @[to_additive]
theorem mulIndicator_eq_self_of_superset (h1 : s.mulIndicator f = f) (h2 : s ⊆ t) :
    t.mulIndicator f = f 
goal: t.indicator f = f

full_name: Set.mulIndicator_eq_self_of_superset
code: @[to_additive]
theorem mulIndicator_eq_self_of_superset (h1 : s.mulIndicator f = f) (h2 : s ⊆ t) :
    t.mulIndicator f = f 
goal: t.mulIndicator f = f

full_name: Set.mulIndicator_apply_eq_one
code: @[to_additive (attr := simp)]
theorem mulIndicator_apply_eq_one : mulIndicator s f a = 1 ↔ a ∈ s → f a = 1 
goal: s.mulIndicator f a = 1 ↔ a ∈ s → f a = 1

full_name: Set.indicator_apply_eq_zero
code: @[to_additive (attr := simp)]
theorem mulIndicator_apply_eq_one : mulIndicator s f a = 1 ↔ a ∈ s → f a = 1 
goal: s.indicator f a = 0 ↔ a ∈ s → f a = 0

full_name: Set.mulIndicator_eq_one
code: @[to_additive (attr := simp)]
theorem mulIndicator_eq_one : (mulIndicator s f = fun x => 1) ↔ Disjoint (mulSupport f) s 
goal: (s.mulIndicator f = fun x => 1) ↔ Disjoint (Function.mulSupport f) s

full_name: Set.indicator_eq_zero
code: @[to_additive (attr := simp)]
theorem mulIndicator_eq_one : (mulIndicator s f = fun x => 1) ↔ Disjoint (mulSupport f) s 
goal: (s.indicator f = fun x => 0) ↔ Disjoint (Function.support f) s

full_name: Set.indicator_eq_zero'
code: @[to_additive (attr := simp)]
theorem mulIndicator_eq_one' : mulIndicator s f = 1 ↔ Disjoint (mulSupport f) s 
goal: s.indicator f = 0 ↔ Disjoint (Function.support f) s

full_name: Set.mulIndicator_eq_one'
code: @[to_additive (attr := simp)]
theorem mulIndicator_eq_one' : mulIndicator s f = 1 ↔ Disjoint (mulSupport f) s 
goal: s.mulIndicator f = 1 ↔ Disjoint (Function.mulSupport f) s

full_name: Set.indicator_apply_ne_zero
code: @[to_additive]
theorem mulIndicator_apply_ne_one {a : α} : s.mulIndicator f a ≠ 1 ↔ a ∈ s ∩ mulSupport f 
goal: s.indicator f a ≠ 0 ↔ a ∈ s ∩ Function.support f

full_name: Set.mulIndicator_apply_ne_one
code: @[to_additive]
theorem mulIndicator_apply_ne_one {a : α} : s.mulIndicator f a ≠ 1 ↔ a ∈ s ∩ mulSupport f 
goal: s.mulIndicator f a ≠ 1 ↔ a ∈ s ∩ Function.mulSupport f

full_name: Set.mulSupport_mulIndicator
code: @[to_additive (attr := simp)]
theorem mulSupport_mulIndicator :
    Function.mulSupport (s.mulIndicator f) = s ∩ Function.mulSupport f 
goal: Function.mulSupport (s.mulIndicator f) = s ∩ Function.mulSupport f

full_name: Set.support_indicator
code: @[to_additive (attr := simp)]
theorem mulSupport_mulIndicator :
    Function.mulSupport (s.mulIndicator f) = s ∩ Function.mulSupport f 
goal: Function.support (s.indicator f) = s ∩ Function.support f

full_name: Set.mem_of_mulIndicator_ne_one
code: /-- If a multiplicative indicator function is not equal to `1` at a point, then that point is in the
set. -/
@[to_additive
      "If an additive indicator function is not equal to `0` at a point, then that point is
      in the set."]
theorem mem_of_mulIndicator_ne_one (h : mulIndicator s f a ≠ 1) : a ∈ s 
goal: a ∈ s

full_name: Set.mem_of_indicator_ne_zero
code: /-- If a multiplicative indicator function is not equal to `1` at a point, then that point is in the
set. -/
@[to_additive
      "If an additive indicator function is not equal to `0` at a point, then that point is
      in the set."]
theorem mem_of_mulIndicator_ne_one (h : mulIndicator s f a ≠ 1) : a ∈ s 
goal: a ∈ s

full_name: Set.eqOn_mulIndicator
code: @[to_additive]
theorem eqOn_mulIndicator : EqOn (mulIndicator s f) f s 
goal: Set.EqOn (s.mulIndicator f) f s

full_name: Set.eqOn_indicator
code: @[to_additive]
theorem eqOn_mulIndicator : EqOn (mulIndicator s f) f s 
goal: Set.EqOn (s.indicator f) f s

full_name: Set.support_indicator_subset
code: @[to_additive]
theorem mulSupport_mulIndicator_subset : mulSupport (s.mulIndicator f) ⊆ s 
goal: Function.support (s.indicator f) ⊆ s

full_name: Set.mulSupport_mulIndicator_subset
code: @[to_additive]
theorem mulSupport_mulIndicator_subset : mulSupport (s.mulIndicator f) ⊆ s 
goal: Function.mulSupport (s.mulIndicator f) ⊆ s

full_name: Set.mulIndicator_mulSupport
code: @[to_additive (attr := simp)]
theorem mulIndicator_mulSupport : mulIndicator (mulSupport f) f = f 
goal: (Function.mulSupport f).mulIndicator f = f

full_name: Set.indicator_support
code: @[to_additive (attr := simp)]
theorem mulIndicator_mulSupport : mulIndicator (mulSupport f) f = f 
goal: (Function.support f).indicator f = f

full_name: Set.indicator_range_comp
code: @[to_additive (attr := simp)]
theorem mulIndicator_range_comp {ι : Sort*} (f : ι → α) (g : α → M) :
    mulIndicator (range f) g ∘ f = g ∘ f 
goal: (Set.range f).indicator g ∘ f = g ∘ f

full_name: Set.mulIndicator_range_comp
code: @[to_additive (attr := simp)]
theorem mulIndicator_range_comp {ι : Sort*} (f : ι → α) (g : α → M) :
    mulIndicator (range f) g ∘ f = g ∘ f 
goal: (Set.range f).mulIndicator g ∘ f = g ∘ f

full_name: Set.mulIndicator_congr
code: @[to_additive]
theorem mulIndicator_congr (h : EqOn f g s) : mulIndicator s f = mulIndicator s g 
goal: s.mulIndicator f = s.mulIndicator g

full_name: Set.indicator_congr
code: @[to_additive]
theorem mulIndicator_congr (h : EqOn f g s) : mulIndicator s f = mulIndicator s g 
goal: s.indicator f = s.indicator g

full_name: Set.mulIndicator_univ
code: @[to_additive (attr := simp)]
theorem mulIndicator_univ (f : α → M) : mulIndicator (univ : Set α) f = f 
goal: Set.univ.mulIndicator f = f

full_name: Set.indicator_univ
code: @[to_additive (attr := simp)]
theorem mulIndicator_univ (f : α → M) : mulIndicator (univ : Set α) f = f 
goal: Set.univ.indicator f = f

full_name: Set.mulIndicator_empty
code: @[to_additive (attr := simp)]
theorem mulIndicator_empty (f : α → M) : mulIndicator (∅ : Set α) f = fun _ => 1 
goal: ∅.mulIndicator f = fun x => 1

full_name: Set.indicator_empty
code: @[to_additive (attr := simp)]
theorem mulIndicator_empty (f : α → M) : mulIndicator (∅ : Set α) f = fun _ => 1 
goal: ∅.indicator f = fun x => 0

full_name: Set.mulIndicator_empty'
code: @[to_additive]
theorem mulIndicator_empty' (f : α → M) : mulIndicator (∅ : Set α) f = 1 
goal: ∅.mulIndicator f = 1

full_name: Set.indicator_empty'
code: @[to_additive]
theorem mulIndicator_empty' (f : α → M) : mulIndicator (∅ : Set α) f = 1 
goal: ∅.indicator f = 0

full_name: Set.indicator_zero
code: @[to_additive (attr := simp)]
theorem mulIndicator_one (s : Set α) : (mulIndicator s fun _ => (1 : M)) = fun _ => (1 : M) 
goal: (s.indicator fun x => 0) = fun x => 0

full_name: Set.mulIndicator_one
code: @[to_additive (attr := simp)]
theorem mulIndicator_one (s : Set α) : (mulIndicator s fun _ => (1 : M)) = fun _ => (1 : M) 
goal: (s.mulIndicator fun x => 1) = fun x => 1

full_name: Set.mulIndicator_one'
code: @[to_additive (attr := simp)]
theorem mulIndicator_one' {s : Set α} : s.mulIndicator (1 : α → M) = 1 
goal: s.mulIndicator 1 = 1

full_name: Set.indicator_zero'
code: @[to_additive (attr := simp)]
theorem mulIndicator_one' {s : Set α} : s.mulIndicator (1 : α → M) = 1 
goal: s.indicator 0 = 0

full_name: Set.indicator_indicator
code: @[to_additive]
theorem mulIndicator_mulIndicator (s t : Set α) (f : α → M) :
    mulIndicator s (mulIndicator t f) = mulIndicator (s ∩ t) f 
goal: s.indicator (t.indicator f) = (s ∩ t).indicator f

full_name: Set.mulIndicator_mulIndicator
code: @[to_additive]
theorem mulIndicator_mulIndicator (s t : Set α) (f : α → M) :
    mulIndicator s (mulIndicator t f) = mulIndicator (s ∩ t) f 
goal: s.mulIndicator (t.mulIndicator f) = (s ∩ t).mulIndicator f

full_name: Set.indicator_inter_support
code: @[to_additive (attr := simp)]
theorem mulIndicator_inter_mulSupport (s : Set α) (f : α → M) :
    mulIndicator (s ∩ mulSupport f) f = mulIndicator s f 
goal: (s ∩ Function.support f).indicator f = s.indicator f

full_name: Set.mulIndicator_inter_mulSupport
code: @[to_additive (attr := simp)]
theorem mulIndicator_inter_mulSupport (s : Set α) (f : α → M) :
    mulIndicator (s ∩ mulSupport f) f = mulIndicator s f 
goal: (s ∩ Function.mulSupport f).mulIndicator f = s.mulIndicator f

full_name: Set.comp_indicator
code: @[to_additive]
theorem comp_mulIndicator (h : M → β) (f : α → M) {s : Set α} {x : α} [DecidablePred (· ∈ s)] :
    h (s.mulIndicator f x) = s.piecewise (h ∘ f) (const α (h 1)) x 
goal: h (s.indicator f x) = s.piecewise (h ∘ f) (Function.const α (h 0)) x

full_name: Set.comp_mulIndicator
code: @[to_additive]
theorem comp_mulIndicator (h : M → β) (f : α → M) {s : Set α} {x : α} [DecidablePred (· ∈ s)] :
    h (s.mulIndicator f x) = s.piecewise (h ∘ f) (const α (h 1)) x 
goal: h (s.mulIndicator f x) = s.piecewise (h ∘ f) (Function.const α (h 1)) x

full_name: Set.indicator_comp_right
code: @[to_additive]
theorem mulIndicator_comp_right {s : Set α} (f : β → α) {g : α → M} {x : β} :
    mulIndicator (f ⁻¹' s) (g ∘ f) x = mulIndicator s g (f x) 
goal: (f ⁻¹' s).indicator (g ∘ f) x = s.indicator g (f x)

full_name: Set.mulIndicator_comp_right
code: @[to_additive]
theorem mulIndicator_comp_right {s : Set α} (f : β → α) {g : α → M} {x : β} :
    mulIndicator (f ⁻¹' s) (g ∘ f) x = mulIndicator s g (f x) 
goal: (f ⁻¹' s).mulIndicator (g ∘ f) x = s.mulIndicator g (f x)

full_name: Set.indicator_image
code: @[to_additive]
theorem mulIndicator_image {s : Set α} {f : β → M} {g : α → β} (hg : Injective g) {x : α} :
    mulIndicator (g '' s) f (g x) = mulIndicator s (f ∘ g) x 
goal: (g '' s).indicator f (g x) = s.indicator (f ∘ g) x

full_name: Set.mulIndicator_image
code: @[to_additive]
theorem mulIndicator_image {s : Set α} {f : β → M} {g : α → β} (hg : Injective g) {x : α} :
    mulIndicator (g '' s) f (g x) = mulIndicator s (f ∘ g) x 
goal: (g '' s).mulIndicator f (g x) = s.mulIndicator (f ∘ g) x

full_name: Set.indicator_comp_of_zero
code: @[to_additive]
theorem mulIndicator_comp_of_one {g : M → N} (hg : g 1 = 1) :
    mulIndicator s (g ∘ f) = g ∘ mulIndicator s f 
goal: s.indicator (g ∘ f) = g ∘ s.indicator f

full_name: Set.mulIndicator_comp_of_one
code: @[to_additive]
theorem mulIndicator_comp_of_one {g : M → N} (hg : g 1 = 1) :
    mulIndicator s (g ∘ f) = g ∘ mulIndicator s f 
goal: s.mulIndicator (g ∘ f) = g ∘ s.mulIndicator f

full_name: Set.comp_indicator_const
code: @[to_additive]
theorem comp_mulIndicator_const (c : M) (f : M → N) (hf : f 1 = 1) :
    (fun x => f (s.mulIndicator (fun _ => c) x)) = s.mulIndicator fun _ => f c 
goal: (fun x => f (s.indicator (fun x => c) x)) = s.indicator fun x => f c

full_name: Set.comp_mulIndicator_const
code: @[to_additive]
theorem comp_mulIndicator_const (c : M) (f : M → N) (hf : f 1 = 1) :
    (fun x => f (s.mulIndicator (fun _ => c) x)) = s.mulIndicator fun _ => f c 
goal: (fun x => f (s.mulIndicator (fun x => c) x)) = s.mulIndicator fun x => f c

full_name: Set.mulIndicator_preimage
code: @[to_additive]
theorem mulIndicator_preimage (s : Set α) (f : α → M) (B : Set M) :
    mulIndicator s f ⁻¹' B = s.ite (f ⁻¹' B) (1 ⁻¹' B) 
goal: s.mulIndicator f ⁻¹' B = s.ite (f ⁻¹' B) (1 ⁻¹' B)

full_name: Set.indicator_preimage
code: @[to_additive]
theorem mulIndicator_preimage (s : Set α) (f : α → M) (B : Set M) :
    mulIndicator s f ⁻¹' B = s.ite (f ⁻¹' B) (1 ⁻¹' B) 
goal: s.indicator f ⁻¹' B = s.ite (f ⁻¹' B) (0 ⁻¹' B)

full_name: Set.indicator_zero_preimage
code: @[to_additive]
theorem mulIndicator_one_preimage (s : Set M) :
    t.mulIndicator 1 ⁻¹' s ∈ ({Set.univ, ∅} : Set (Set α)) 
goal: t.indicator 0 ⁻¹' s ∈ {Set.univ, ∅}

full_name: Set.mulIndicator_one_preimage
code: @[to_additive]
theorem mulIndicator_one_preimage (s : Set M) :
    t.mulIndicator 1 ⁻¹' s ∈ ({Set.univ, ∅} : Set (Set α)) 
goal: t.mulIndicator 1 ⁻¹' s ∈ {Set.univ, ∅}

full_name: Set.indicator_const_preimage_eq_union
code: @[to_additive]
theorem mulIndicator_const_preimage_eq_union (U : Set α) (s : Set M) (a : M) [Decidable (a ∈ s)]
    [Decidable ((1 : M) ∈ s)] : (U.mulIndicator fun _ => a) ⁻¹' s =
      (if a ∈ s then U else ∅) ∪ if (1 : M) ∈ s then Uᶜ else ∅ 
goal: (U.indicator fun x => a) ⁻¹' s = (if a ∈ s then U else ∅) ∪ if 0 ∈ s then Uᶜ else ∅

full_name: Set.mulIndicator_const_preimage_eq_union
code: @[to_additive]
theorem mulIndicator_const_preimage_eq_union (U : Set α) (s : Set M) (a : M) [Decidable (a ∈ s)]
    [Decidable ((1 : M) ∈ s)] : (U.mulIndicator fun _ => a) ⁻¹' s =
      (if a ∈ s then U else ∅) ∪ if (1 : M) ∈ s then Uᶜ else ∅ 
goal: (U.mulIndicator fun x => a) ⁻¹' s = (if a ∈ s then U else ∅) ∪ if 1 ∈ s then Uᶜ else ∅

full_name: Set.indicator_const_preimage
code: @[to_additive]
theorem mulIndicator_const_preimage (U : Set α) (s : Set M) (a : M) :
    (U.mulIndicator fun _ => a) ⁻¹' s ∈ ({Set.univ, U, Uᶜ, ∅} : Set (Set α)) 
goal: (U.indicator fun x => a) ⁻¹' s ∈ {Set.univ, U, Uᶜ, ∅}

full_name: Set.mulIndicator_const_preimage
code: @[to_additive]
theorem mulIndicator_const_preimage (U : Set α) (s : Set M) (a : M) :
    (U.mulIndicator fun _ => a) ⁻¹' s ∈ ({Set.univ, U, Uᶜ, ∅} : Set (Set α)) 
goal: (U.mulIndicator fun x => a) ⁻¹' s ∈ {Set.univ, U, Uᶜ, ∅}

full_name: Set.indicator_one_preimage
code: theorem indicator_one_preimage [Zero M] (U : Set α) (s : Set M) :
    U.indicator 1 ⁻¹' s ∈ ({Set.univ, U, Uᶜ, ∅} : Set (Set α)) 
goal: U.indicator 1 ⁻¹' s ∈ {Set.univ, U, Uᶜ, ∅}

full_name: Set.indicator_preimage_of_not_mem
code: @[to_additive]
theorem mulIndicator_preimage_of_not_mem (s : Set α) (f : α → M) {t : Set M} (ht : (1 : M) ∉ t) :
    mulIndicator s f ⁻¹' t = f ⁻¹' t ∩ s 
goal: s.indicator f ⁻¹' t = f ⁻¹' t ∩ s

full_name: Set.mulIndicator_preimage_of_not_mem
code: @[to_additive]
theorem mulIndicator_preimage_of_not_mem (s : Set α) (f : α → M) {t : Set M} (ht : (1 : M) ∉ t) :
    mulIndicator s f ⁻¹' t = f ⁻¹' t ∩ s 
goal: s.mulIndicator f ⁻¹' t = f ⁻¹' t ∩ s

full_name: Set.mem_range_mulIndicator
code: @[to_additive]
theorem mem_range_mulIndicator {r : M} {s : Set α} {f : α → M} :
    r ∈ range (mulIndicator s f) ↔ r = 1 ∧ s ≠ univ ∨ r ∈ f '' s 
goal: r ∈ Set.range (s.mulIndicator f) ↔ r = 1 ∧ s ≠ Set.univ ∨ r ∈ f '' s

full_name: Set.mem_range_indicator
code: @[to_additive]
theorem mem_range_mulIndicator {r : M} {s : Set α} {f : α → M} :
    r ∈ range (mulIndicator s f) ↔ r = 1 ∧ s ≠ univ ∨ r ∈ f '' s 
goal: r ∈ Set.range (s.indicator f) ↔ r = 0 ∧ s ≠ Set.univ ∨ r ∈ f '' s

full_name: Set.indicator_rel_indicator
code: @[to_additive]
theorem mulIndicator_rel_mulIndicator {r : M → M → Prop} (h1 : r 1 1) (ha : a ∈ s → r (f a) (g a)) :
    r (mulIndicator s f a) (mulIndicator s g a) 
goal: r (s.indicator f a) (s.indicator g a)

full_name: Set.mulIndicator_rel_mulIndicator
code: @[to_additive]
theorem mulIndicator_rel_mulIndicator {r : M → M → Prop} (h1 : r 1 1) (ha : a ∈ s → r (f a) (g a)) :
    r (mulIndicator s f a) (mulIndicator s g a) 
goal: r (s.mulIndicator f a) (s.mulIndicator g a)

full_name: Set.indicator_union_add_inter_apply
code: @[to_additive]
theorem mulIndicator_union_mul_inter_apply (f : α → M) (s t : Set α) (a : α) :
    mulIndicator (s ∪ t) f a * mulIndicator (s ∩ t) f a
      = mulIndicator s f a * mulIndicator t f a 
goal: (s ∪ t).indicator f a + (s ∩ t).indicator f a = s.indicator f a + t.indicator f a

full_name: Set.mulIndicator_union_mul_inter_apply
code: @[to_additive]
theorem mulIndicator_union_mul_inter_apply (f : α → M) (s t : Set α) (a : α) :
    mulIndicator (s ∪ t) f a * mulIndicator (s ∩ t) f a
      = mulIndicator s f a * mulIndicator t f a 
goal: (s ∪ t).mulIndicator f a * (s ∩ t).mulIndicator f a = s.mulIndicator f a * t.mulIndicator f a

full_name: Set.mulIndicator_union_mul_inter
code: @[to_additive]
theorem mulIndicator_union_mul_inter (f : α → M) (s t : Set α) :
    mulIndicator (s ∪ t) f * mulIndicator (s ∩ t) f = mulIndicator s f * mulIndicator t f 
goal: (s ∪ t).mulIndicator f * (s ∩ t).mulIndicator f = s.mulIndicator f * t.mulIndicator f

full_name: Set.indicator_union_add_inter
code: @[to_additive]
theorem mulIndicator_union_mul_inter (f : α → M) (s t : Set α) :
    mulIndicator (s ∪ t) f * mulIndicator (s ∩ t) f = mulIndicator s f * mulIndicator t f 
goal: (s ∪ t).indicator f + (s ∩ t).indicator f = s.indicator f + t.indicator f

full_name: Set.indicator_union_of_not_mem_inter
code: @[to_additive]
theorem mulIndicator_union_of_not_mem_inter (h : a ∉ s ∩ t) (f : α → M) :
    mulIndicator (s ∪ t) f a = mulIndicator s f a * mulIndicator t f a 
goal: (s ∪ t).indicator f a = s.indicator f a + t.indicator f a

full_name: Set.mulIndicator_union_of_not_mem_inter
code: @[to_additive]
theorem mulIndicator_union_of_not_mem_inter (h : a ∉ s ∩ t) (f : α → M) :
    mulIndicator (s ∪ t) f a = mulIndicator s f a * mulIndicator t f a 
goal: (s ∪ t).mulIndicator f a = s.mulIndicator f a * t.mulIndicator f a

full_name: Set.mulIndicator_union_of_disjoint
code: @[to_additive]
theorem mulIndicator_union_of_disjoint (h : Disjoint s t) (f : α → M) :
    mulIndicator (s ∪ t) f = fun a => mulIndicator s f a * mulIndicator t f a 
goal: (s ∪ t).mulIndicator f = fun a => s.mulIndicator f a * t.mulIndicator f a

full_name: Set.indicator_union_of_disjoint
code: @[to_additive]
theorem mulIndicator_union_of_disjoint (h : Disjoint s t) (f : α → M) :
    mulIndicator (s ∪ t) f = fun a => mulIndicator s f a * mulIndicator t f a 
goal: (s ∪ t).indicator f = fun a => s.indicator f a + t.indicator f a

full_name: Set.mulIndicator_symmDiff
code: @[to_additive]
theorem mulIndicator_symmDiff (s t : Set α) (f : α → M) :
    mulIndicator (s ∆ t) f = mulIndicator (s \ t) f * mulIndicator (t \ s) f 
goal: (symmDiff s t).mulIndicator f = (s \ t).mulIndicator f * (t \ s).mulIndicator f

full_name: Set.indicator_symmDiff
code: @[to_additive]
theorem mulIndicator_symmDiff (s t : Set α) (f : α → M) :
    mulIndicator (s ∆ t) f = mulIndicator (s \ t) f * mulIndicator (t \ s) f 
goal: (symmDiff s t).indicator f = (s \ t).indicator f + (t \ s).indicator f

full_name: Set.indicator_add
code: @[to_additive]
theorem mulIndicator_mul (s : Set α) (f g : α → M) :
    (mulIndicator s fun a => f a * g a) = fun a => mulIndicator s f a * mulIndicator s g a 
goal: (s.indicator fun a => f a + g a) = fun a => s.indicator f a + s.indicator g a

full_name: Set.mulIndicator_mul
code: @[to_additive]
theorem mulIndicator_mul (s : Set α) (f g : α → M) :
    (mulIndicator s fun a => f a * g a) = fun a => mulIndicator s f a * mulIndicator s g a 
goal: (s.mulIndicator fun a => f a * g a) = fun a => s.mulIndicator f a * s.mulIndicator g a

full_name: Set.mulIndicator_mul'
code: @[to_additive]
theorem mulIndicator_mul' (s : Set α) (f g : α → M) :
    mulIndicator s (f * g) = mulIndicator s f * mulIndicator s g 
goal: s.mulIndicator (f * g) = s.mulIndicator f * s.mulIndicator g

full_name: Set.indicator_add'
code: @[to_additive]
theorem mulIndicator_mul' (s : Set α) (f g : α → M) :
    mulIndicator s (f * g) = mulIndicator s f * mulIndicator s g 
goal: s.indicator (f + g) = s.indicator f + s.indicator g

full_name: Set.mulIndicator_compl_mul_self_apply
code: @[to_additive (attr := simp)]
theorem mulIndicator_compl_mul_self_apply (s : Set α) (f : α → M) (a : α) :
    mulIndicator sᶜ f a * mulIndicator s f a = f a 
goal: sᶜ.mulIndicator f a * s.mulIndicator f a = f a

full_name: Set.indicator_compl_add_self_apply
code: @[to_additive (attr := simp)]
theorem mulIndicator_compl_mul_self_apply (s : Set α) (f : α → M) (a : α) :
    mulIndicator sᶜ f a * mulIndicator s f a = f a 
goal: sᶜ.indicator f a + s.indicator f a = f a

full_name: Set.indicator_compl_add_self
code: @[to_additive (attr := simp)]
theorem mulIndicator_compl_mul_self (s : Set α) (f : α → M) :
    mulIndicator sᶜ f * mulIndicator s f = f 
goal: sᶜ.indicator f + s.indicator f = f

full_name: Set.mulIndicator_compl_mul_self
code: @[to_additive (attr := simp)]
theorem mulIndicator_compl_mul_self (s : Set α) (f : α → M) :
    mulIndicator sᶜ f * mulIndicator s f = f 
goal: sᶜ.mulIndicator f * s.mulIndicator f = f

full_name: Set.mulIndicator_self_mul_compl_apply
code: @[to_additive (attr := simp)]
theorem mulIndicator_self_mul_compl_apply (s : Set α) (f : α → M) (a : α) :
    mulIndicator s f a * mulIndicator sᶜ f a = f a 
goal: s.mulIndicator f a * sᶜ.mulIndicator f a = f a

full_name: Set.indicator_self_add_compl_apply
code: @[to_additive (attr := simp)]
theorem mulIndicator_self_mul_compl_apply (s : Set α) (f : α → M) (a : α) :
    mulIndicator s f a * mulIndicator sᶜ f a = f a 
goal: s.indicator f a + sᶜ.indicator f a = f a

full_name: Set.indicator_self_add_compl
code: @[to_additive (attr := simp)]
theorem mulIndicator_self_mul_compl (s : Set α) (f : α → M) :
    mulIndicator s f * mulIndicator sᶜ f = f 
goal: s.indicator f + sᶜ.indicator f = f

full_name: Set.mulIndicator_self_mul_compl
code: @[to_additive (attr := simp)]
theorem mulIndicator_self_mul_compl (s : Set α) (f : α → M) :
    mulIndicator s f * mulIndicator sᶜ f = f 
goal: s.mulIndicator f * sᶜ.mulIndicator f = f

full_name: Set.mulIndicator_mul_eq_left
code: @[to_additive]
theorem mulIndicator_mul_eq_left {f g : α → M} (h : Disjoint (mulSupport f) (mulSupport g)) :
    (mulSupport f).mulIndicator (f * g) = f 
goal: (Function.mulSupport f).mulIndicator (f * g) = f

full_name: Set.indicator_add_eq_left
code: @[to_additive]
theorem mulIndicator_mul_eq_left {f g : α → M} (h : Disjoint (mulSupport f) (mulSupport g)) :
    (mulSupport f).mulIndicator (f * g) = f 
goal: (Function.support f).indicator (f + g) = f

full_name: Set.mulIndicator_mul_eq_right
code: @[to_additive]
theorem mulIndicator_mul_eq_right {f g : α → M} (h : Disjoint (mulSupport f) (mulSupport g)) :
    (mulSupport g).mulIndicator (f * g) = g 
goal: (Function.mulSupport g).mulIndicator (f * g) = g

full_name: Set.indicator_add_eq_right
code: @[to_additive]
theorem mulIndicator_mul_eq_right {f g : α → M} (h : Disjoint (mulSupport f) (mulSupport g)) :
    (mulSupport g).mulIndicator (f * g) = g 
goal: (Function.support g).indicator (f + g) = g

full_name: Set.indicator_add_compl_eq_piecewise
code: @[to_additive]
theorem mulIndicator_mul_compl_eq_piecewise [DecidablePred (· ∈ s)] (f g : α → M) :
    s.mulIndicator f * sᶜ.mulIndicator g = s.piecewise f g 
goal: s.indicator f + sᶜ.indicator g = s.piecewise f g

full_name: Set.mulIndicator_mul_compl_eq_piecewise
code: @[to_additive]
theorem mulIndicator_mul_compl_eq_piecewise [DecidablePred (· ∈ s)] (f g : α → M) :
    s.mulIndicator f * sᶜ.mulIndicator g = s.piecewise f g 
goal: s.mulIndicator f * sᶜ.mulIndicator g = s.piecewise f g

full_name: Set.indicatorHom
code: /-- `Set.mulIndicator` as a `monoidHom`. -/
@[to_additive "`Set.indicator` as an `addMonoidHom`."]
noncomputable def mulIndicatorHom {α} (M) [MulOneClass M] (s : Set α) : (α → M) →* α → M 
goal: (α → M) →+ α → M

full_name: Set.mulIndicatorHom
code: /-- `Set.mulIndicator` as a `monoidHom`. -/
@[to_additive "`Set.indicator` as an `addMonoidHom`."]
noncomputable def mulIndicatorHom {α} (M) [MulOneClass M] (s : Set α) : (α → M) →* α → M 
goal: (α → M) →* α → M

full_name: Set.mulIndicator_inv'
code: @[to_additive]
theorem mulIndicator_inv' (s : Set α) (f : α → G) : mulIndicator s f⁻¹ = (mulIndicator s f)⁻¹ 
goal: s.mulIndicator f⁻¹ = (s.mulIndicator f)⁻¹

full_name: Set.indicator_neg'
code: @[to_additive]
theorem mulIndicator_inv' (s : Set α) (f : α → G) : mulIndicator s f⁻¹ = (mulIndicator s f)⁻¹ 
goal: s.indicator (-f) = -s.indicator f

full_name: Set.indicator_neg
code: @[to_additive]
theorem mulIndicator_inv (s : Set α) (f : α → G) :
    (mulIndicator s fun a => (f a)⁻¹) = fun a => (mulIndicator s f a)⁻¹ 
goal: (s.indicator fun a => -f a) = fun a => -s.indicator f a

full_name: Set.mulIndicator_inv
code: @[to_additive]
theorem mulIndicator_inv (s : Set α) (f : α → G) :
    (mulIndicator s fun a => (f a)⁻¹) = fun a => (mulIndicator s f a)⁻¹ 
goal: (s.mulIndicator fun a => (f a)⁻¹) = fun a => (s.mulIndicator f a)⁻¹

full_name: Set.indicator_sub
code: @[to_additive]
theorem mulIndicator_div (s : Set α) (f g : α → G) :
    (mulIndicator s fun a => f a / g a) = fun a => mulIndicator s f a / mulIndicator s g a 
goal: (s.indicator fun a => f a - g a) = fun a => s.indicator f a - s.indicator g a

full_name: Set.mulIndicator_div
code: @[to_additive]
theorem mulIndicator_div (s : Set α) (f g : α → G) :
    (mulIndicator s fun a => f a / g a) = fun a => mulIndicator s f a / mulIndicator s g a 
goal: (s.mulIndicator fun a => f a / g a) = fun a => s.mulIndicator f a / s.mulIndicator g a

full_name: Set.indicator_sub'
code: @[to_additive]
theorem mulIndicator_div' (s : Set α) (f g : α → G) :
    mulIndicator s (f / g) = mulIndicator s f / mulIndicator s g 
goal: s.indicator (f - g) = s.indicator f - s.indicator g

full_name: Set.mulIndicator_div'
code: @[to_additive]
theorem mulIndicator_div' (s : Set α) (f g : α → G) :
    mulIndicator s (f / g) = mulIndicator s f / mulIndicator s g 
goal: s.mulIndicator (f / g) = s.mulIndicator f / s.mulIndicator g

full_name: Set.mulIndicator_compl
code: @[to_additive indicator_compl']
theorem mulIndicator_compl (s : Set α) (f : α → G) :
    mulIndicator sᶜ f = f * (mulIndicator s f)⁻¹ 
goal: sᶜ.mulIndicator f = f * (s.mulIndicator f)⁻¹

full_name: Set.indicator_compl'
code: @[to_additive indicator_compl']
theorem mulIndicator_compl (s : Set α) (f : α → G) :
    mulIndicator sᶜ f = f * (mulIndicator s f)⁻¹ 
goal: sᶜ.indicator f = f + -s.indicator f

full_name: Set.indicator_compl
code: @[to_additive indicator_compl]
theorem mulIndicator_compl' (s : Set α) (f : α → G) :
    mulIndicator sᶜ f = f / mulIndicator s f 
goal: sᶜ.indicator f = f - s.indicator f

full_name: Set.mulIndicator_compl'
code: @[to_additive indicator_compl]
theorem mulIndicator_compl' (s : Set α) (f : α → G) :
    mulIndicator sᶜ f = f / mulIndicator s f 
goal: sᶜ.mulIndicator f = f / s.mulIndicator f

full_name: Set.mulIndicator_diff
code: @[to_additive indicator_diff']
theorem mulIndicator_diff (h : s ⊆ t) (f : α → G) :
    mulIndicator (t \ s) f = mulIndicator t f * (mulIndicator s f)⁻¹ 
goal: (t \ s).mulIndicator f = t.mulIndicator f * (s.mulIndicator f)⁻¹

full_name: Set.indicator_diff'
code: @[to_additive indicator_diff']
theorem mulIndicator_diff (h : s ⊆ t) (f : α → G) :
    mulIndicator (t \ s) f = mulIndicator t f * (mulIndicator s f)⁻¹ 
goal: (t \ s).indicator f = t.indicator f + -s.indicator f

full_name: Set.mulIndicator_diff'
code: @[to_additive indicator_diff]
theorem mulIndicator_diff' (h : s ⊆ t) (f : α → G) :
    mulIndicator (t \ s) f = mulIndicator t f / mulIndicator s f 
goal: (t \ s).mulIndicator f = t.mulIndicator f / s.mulIndicator f

full_name: Set.indicator_diff
code: @[to_additive indicator_diff]
theorem mulIndicator_diff' (h : s ⊆ t) (f : α → G) :
    mulIndicator (t \ s) f = mulIndicator t f / mulIndicator s f 
goal: (t \ s).indicator f = t.indicator f - s.indicator f

full_name: Set.apply_indicator_symmDiff
code: @[to_additive]
theorem apply_mulIndicator_symmDiff {g : G → β} (hg : ∀ x, g x⁻¹ = g x)
    (s t : Set α) (f : α → G) (x : α) :
    g (mulIndicator (s ∆ t) f x) = g (mulIndicator s f x / mulIndicator t f x) 
goal: g ((symmDiff s t).indicator f x) = g (s.indicator f x - t.indicator f x)

full_name: Set.apply_mulIndicator_symmDiff
code: @[to_additive]
theorem apply_mulIndicator_symmDiff {g : G → β} (hg : ∀ x, g x⁻¹ = g x)
    (s t : Set α) (f : α → G) (x : α) :
    g (mulIndicator (s ∆ t) f x) = g (mulIndicator s f x / mulIndicator t f x) 
goal: g ((symmDiff s t).mulIndicator f x) = g (s.mulIndicator f x / t.mulIndicator f x)

full_name: AddMonoidHom.map_indicator
code: @[to_additive]
theorem MonoidHom.map_mulIndicator {M N : Type*} [MulOneClass M] [MulOneClass N] (f : M →* N)
    (s : Set α) (g : α → M) (x : α) : f (s.mulIndicator g x) = s.mulIndicator (f ∘ g) x 
goal: f (s.indicator g x) = s.indicator (⇑f ∘ g) x

full_name: MonoidHom.map_mulIndicator
code: @[to_additive]
theorem MonoidHom.map_mulIndicator {M N : Type*} [MulOneClass M] [MulOneClass N] (f : M →* N)
    (s : Set α) (g : α → M) (x : α) : f (s.mulIndicator g x) = s.mulIndicator (f ∘ g) x 
goal: f (s.mulIndicator g x) = s.mulIndicator (⇑f ∘ g) x