ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finset.image_biUnion_filter_eq
theorem image_biUnion_filter_eq [DecidableEq α] (s : Finset β) (g : β → α) :
    ((s.image g).biUnion fun a => s.filter fun c => g c = a) = s 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] [DecidableEq α] (s : Finset β) (g : β → α)
Goal: ((Finset.image g s).biUnion fun a => Finset.filter (fun c => g c = a) s) = s
-- Finset.biUnion_singleton
theorem biUnion_singleton {f : α → β} : (s.biUnion fun a => {f a}) = s.image f 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] {s : Finset α} {f : α → β}
Goal: (s.biUnion fun a => {f a}) = Finset.image f s
-- Finset.filterMap_val
@[simp]
theorem filterMap_val : (filterMap f s' f_inj).1 = s'.1.filterMap f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Option β) (s' : Finset α) {f_inj : ∀ (a a' : α), ∀ b ∈ f a, b ∈ f a' → a = a'}
Goal: (Finset.filterMap f s' f_inj).val = Multiset.filterMap f s'.val
-- Finset.filterMap_empty
@[simp]
theorem filterMap_empty : (∅ : Finset α).filterMap f f_inj = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Option β) {f_inj : ∀ (a a' : α), ∀ b ∈ f a, b ∈ f a' → a = a'}
Goal: Finset.filterMap f ∅ f_inj = ∅
-- Finset.mem_filterMap
@[simp]
theorem mem_filterMap {b : β} : b ∈ s.filterMap f f_inj ↔ ∃ a ∈ s, f a = some b 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Option β) {s : Finset α} {f_inj : ∀ (a a' : α), ∀ b ∈ f a, b ∈ f a' → a = a'} {b : β}
Goal: b ∈ Finset.filterMap f s f_inj ↔ ∃ a ∈ s, f a = some b
-- Finset.coe_filterMap
@[simp, norm_cast]
theorem coe_filterMap : (s.filterMap f f_inj : Set β) = {b | ∃ a ∈ s, f a = some b} 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Option β) {s : Finset α} {f_inj : ∀ (a a' : α), ∀ b ∈ f a, b ∈ f a' → a = a'}
Goal: ↑(Finset.filterMap f s f_inj) = {b | ∃ a ∈ s, f a = some b}
-- Finset.filterMap_some
@[simp]
theorem filterMap_some : s.filterMap some (by simp) = s 
Arguments: {α : Type u_1} {s : Finset α}
Goal: Finset.filterMap some s ⋯ = s
-- Finset.filterMap_mono
theorem filterMap_mono (h : s ⊆ t) :
    filterMap f s f_inj ⊆ filterMap f t f_inj 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Option β) {s t : Finset α} {f_inj : ∀ (a a' : α), ∀ b ∈ f a, b ∈ f a' → a = a'} (h : s ⊆ t)
Goal: Finset.filterMap f s f_inj ⊆ Finset.filterMap f t f_inj
-- Finset.mem_subtype
@[simp]
theorem mem_subtype {p : α → Prop} [DecidablePred p] {s : Finset α} :
    ∀ {a : Subtype p}, a ∈ s.subtype p ↔ (a : α) ∈ s
  
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {s : Finset α} {a : Subtype p}
Goal: a ∈ Finset.subtype p s ↔ ↑a ∈ s
-- Finset.subtype_eq_empty
theorem subtype_eq_empty {p : α → Prop} [DecidablePred p] {s : Finset α} :
    s.subtype p = ∅ ↔ ∀ x, p x → x ∉ s 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {s : Finset α}
Goal: Finset.subtype p s = ∅ ↔ ∀ (x : α), p x → x ∉ s
-- Finset.subtype_mono
@[mono]
theorem subtype_mono {p : α → Prop} [DecidablePred p] : Monotone (Finset.subtype p) 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p]
Goal: Monotone (Finset.subtype p)
-- Finset.subtype_map
@[simp]
theorem subtype_map (p : α → Prop) [DecidablePred p] {s : Finset α} :
    (s.subtype p).map (Embedding.subtype _) = s.filter p 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] {s : Finset α}
Goal: Finset.map (Function.Embedding.subtype p) (Finset.subtype p s) = Finset.filter p s
-- Finset.subtype_map_of_mem
theorem subtype_map_of_mem {p : α → Prop} [DecidablePred p] {s : Finset α} (h : ∀ x ∈ s, p x) :
    (s.subtype p).map (Embedding.subtype _) = s 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {s : Finset α} (h : ∀ x ∈ s, p x)
Goal: Finset.map (Function.Embedding.subtype p) (Finset.subtype p s) = s
-- Finset.property_of_mem_map_subtype
theorem property_of_mem_map_subtype {p : α → Prop} (s : Finset { x // p x }) {a : α}
    (h : a ∈ s.map (Embedding.subtype _)) : p a 
Arguments: {α : Type u_1} {p : α → Prop} (s : Finset { x // p x }) {a : α} (h : a ∈ Finset.map (Function.Embedding.subtype fun x => p x) s)
Goal: p a
-- Finset.not_mem_map_subtype_of_not_property
theorem not_mem_map_subtype_of_not_property {p : α → Prop} (s : Finset { x // p x }) {a : α}
    (h : ¬p a) : a ∉ s.map (Embedding.subtype _) 
Arguments: {α : Type u_1} {p : α → Prop} (s : Finset { x // p x }) {a : α} (h : ¬p a)
Goal: a ∉ Finset.map (Function.Embedding.subtype fun x => p x) s
-- Finset.map_subtype_subset
theorem map_subtype_subset {t : Set α} (s : Finset t) : ↑(s.map (Embedding.subtype _)) ⊆ t 
Arguments: {α : Type u_1} {t : Set α} (s : Finset ↑t)
Goal: ↑(Finset.map (Function.Embedding.subtype fun x => x ∈ t) s) ⊆ t
-- Finset.mem_fin
@[simp]
theorem mem_fin {n} {s : Finset ℕ} : ∀ a : Fin n, a ∈ s.fin n ↔ (a : ℕ) ∈ s
  
Arguments: {n : ℕ} {s : Finset ℕ} (a : Fin n)
Goal: a ∈ Finset.fin n s ↔ ↑a ∈ s
-- Finset.fin_mono
@[mono]
theorem fin_mono {n} : Monotone (Finset.fin n) 
Arguments: {n : ℕ}
Goal: Monotone (Finset.fin n)
-- Finset.fin_map
@[simp]
theorem fin_map {n} {s : Finset ℕ} : (s.fin n).map Fin.valEmbedding = s.filter (· < n) 
Arguments: {n : ℕ} {s : Finset ℕ}
Goal: Finset.map Fin.valEmbedding (Finset.fin n s) = Finset.filter (fun x => x < n) s
-- Finset.subset_image_iff
theorem subset_image_iff [DecidableEq β] {s : Set α} {t : Finset β} {f : α → β} :
    ↑t ⊆ f '' s ↔ ∃ s' : Finset α, ↑s' ⊆ s ∧ s'.image f = t 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] {s : Set α} {t : Finset β} {f : α → β}
Goal: ↑t ⊆ f '' s ↔ ∃ s', ↑s' ⊆ s ∧ Finset.image f s' = t
-- Finset.range_sdiff_zero
theorem range_sdiff_zero {n : ℕ} : range (n + 1) \ {0} = (range n).image Nat.succ 
Arguments: {n : ℕ}
Goal: Finset.range (n + 1) \ {0} = Finset.image Nat.succ (Finset.range n)
-- Multiset.toFinset_map
theorem Multiset.toFinset_map [DecidableEq α] [DecidableEq β] (f : α → β) (m : Multiset α) :
    (m.map f).toFinset = m.toFinset.image f 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq α] [DecidableEq β] (f : α → β) (m : Multiset α)
Goal: (Multiset.map f m).toFinset = Finset.image f m.toFinset
-- Equiv.finsetCongr_apply
@[simp]
theorem finsetCongr_apply (e : α ≃ β) (s : Finset α) : e.finsetCongr s = s.map e.toEmbedding 
Arguments: {α : Type u_1} {β : Type u_2} (e : α ≃ β) (s : Finset α)
Goal: e.finsetCongr s = Finset.map e.toEmbedding s
-- Equiv.finsetCongr_refl
@[simp]
theorem finsetCongr_refl : (Equiv.refl α).finsetCongr = Equiv.refl _ 
Arguments: {α : Type u_1}
Goal: (Equiv.refl α).finsetCongr = Equiv.refl (Finset α)
-- Equiv.finsetCongr_symm
@[simp]
theorem finsetCongr_symm (e : α ≃ β) : e.finsetCongr.symm = e.symm.finsetCongr 
Arguments: {α : Type u_1} {β : Type u_2} (e : α ≃ β)
Goal: e.finsetCongr.symm = e.symm.finsetCongr
-- Equiv.finsetCongr_trans
@[simp]
theorem finsetCongr_trans (e : α ≃ β) (e' : β ≃ γ) :
    e.finsetCongr.trans e'.finsetCongr = (e.trans e').finsetCongr 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (e' : β ≃ γ)
Goal: e.finsetCongr.trans e'.finsetCongr = (e.trans e').finsetCongr
-- Equiv.finsetCongr_toEmbedding
theorem finsetCongr_toEmbedding (e : α ≃ β) :
    e.finsetCongr.toEmbedding = (Finset.mapEmbedding e.toEmbedding).toEmbedding 
Arguments: {α : Type u_1} {β : Type u_2} (e : α ≃ β)
Goal: e.finsetCongr.toEmbedding = (Finset.mapEmbedding e.toEmbedding).toEmbedding
-- Multiset.noncommFoldr_coe
@[simp]
theorem noncommFoldr_coe (l : List α) (comm) (b : β) :
    noncommFoldr f (l : Multiset α) comm b = l.foldr f b 
Arguments: {α : Type u_3} {β : Type u_4} (f : α → β → β) (l : List α) (comm : {x | x ∈ ↑l}.Pairwise fun x y => ∀ (b : β), f x (f y b) = f y (f x b)) (b : β)
Goal: Multiset.noncommFoldr f (↑l) comm b = List.foldr f b l
-- Multiset.noncommFoldr_empty
@[simp]
theorem noncommFoldr_empty (h) (b : β) : noncommFoldr f (0 : Multiset α) h b = b 
Arguments: {α : Type u_3} {β : Type u_4} (f : α → β → β) (h : {x | x ∈ 0}.Pairwise fun x y => ∀ (b : β), f x (f y b) = f y (f x b)) (b : β)
Goal: Multiset.noncommFoldr f 0 h b = b
-- Multiset.noncommFoldr_cons
theorem noncommFoldr_cons (s : Multiset α) (a : α) (h h') (b : β) :
    noncommFoldr f (a ::ₘ s) h b = f a (noncommFoldr f s h' b) 
Arguments: {α : Type u_3} {β : Type u_4} (f : α → β → β) (s : Multiset α) (a : α) (h : {x | x ∈ a ::ₘ s}.Pairwise fun x y => ∀ (b : β), f x (f y b) = f y (f x b)) (h' : {x | x ∈ s}.Pairwise fun x y => ∀ (b : β), f x (f y b) = f y (f x b)) (b : β)
Goal: Multiset.noncommFoldr f (a ::ₘ s) h b = f a (Multiset.noncommFoldr f s h' b)
-- Multiset.noncommFoldr_eq_foldr
theorem noncommFoldr_eq_foldr (s : Multiset α) (h : LeftCommutative f) (b : β) :
    noncommFoldr f s (fun x _ y _ _ => h x y) b = foldr f h b s 
Arguments: {α : Type u_3} {β : Type u_4} (f : α → β → β) (s : Multiset α) (h : LeftCommutative f) (b : β)
Goal: Multiset.noncommFoldr f s ⋯ b = Multiset.foldr f h b s
-- Multiset.noncommFold_coe
@[simp]
theorem noncommFold_coe (l : List α) (comm) (a : α) :
    noncommFold op (l : Multiset α) comm a = l.foldr op a 
Arguments: {α : Type u_3} (op : α → α → α) [assoc : Std.Associative op] (l : List α) (comm : {x | x ∈ ↑l}.Pairwise fun x y => op x y = op y x) (a : α)
Goal: Multiset.noncommFold op (↑l) comm a = List.foldr op a l
-- Multiset.noncommFold_empty
@[simp]
theorem noncommFold_empty (h) (a : α) : noncommFold op (0 : Multiset α) h a = a 
Arguments: {α : Type u_3} (op : α → α → α) [assoc : Std.Associative op] (h : {x | x ∈ 0}.Pairwise fun x y => op x y = op y x) (a : α)
Goal: Multiset.noncommFold op 0 h a = a
-- Multiset.noncommFold_cons
theorem noncommFold_cons (s : Multiset α) (a : α) (h h') (x : α) :
    noncommFold op (a ::ₘ s) h x = op a (noncommFold op s h' x) 
Arguments: {α : Type u_3} (op : α → α → α) [assoc : Std.Associative op] (s : Multiset α) (a : α) (h : {x | x ∈ a ::ₘ s}.Pairwise fun x y => op x y = op y x) (h' : {x | x ∈ s}.Pairwise fun x y => op x y = op y x) (x : α)
Goal: Multiset.noncommFold op (a ::ₘ s) h x = op a (Multiset.noncommFold op s h' x)
-- Multiset.noncommFold_eq_fold
theorem noncommFold_eq_fold (s : Multiset α) [Std.Commutative op] (a : α) :
    noncommFold op s (fun x _ y _ _ => Std.Commutative.comm x y) a = fold op a s 
Arguments: {α : Type u_3} (op : α → α → α) [assoc : Std.Associative op] (s : Multiset α) [Std.Commutative op] (a : α)
Goal: Multiset.noncommFold op s ⋯ a = Multiset.fold op a s
-- Multiset.noncommSum_coe
@[to_additive (attr := simp)]
theorem noncommProd_coe (l : List α) (comm) : noncommProd (l : Multiset α) comm = l.prod 
Arguments: {α : Type u_3} [AddMonoid α] (l : List α) (comm : {x | x ∈ ↑l}.Pairwise AddCommute)
Goal: (↑l).noncommSum comm = l.sum
-- Multiset.noncommProd_coe
@[to_additive (attr := simp)]
theorem noncommProd_coe (l : List α) (comm) : noncommProd (l : Multiset α) comm = l.prod 
Arguments: {α : Type u_3} [Monoid α] (l : List α) (comm : {x | x ∈ ↑l}.Pairwise Commute)
Goal: (↑l).noncommProd comm = l.prod
-- Multiset.noncommProd_empty
@[to_additive (attr := simp)]
theorem noncommProd_empty (h) : noncommProd (0 : Multiset α) h = 1 
Arguments: {α : Type u_3} [Monoid α] (h : {x | x ∈ 0}.Pairwise Commute)
Goal: Multiset.noncommProd 0 h = 1
-- Multiset.noncommSum_empty
@[to_additive (attr := simp)]
theorem noncommProd_empty (h) : noncommProd (0 : Multiset α) h = 1 
Arguments: {α : Type u_3} [AddMonoid α] (h : {x | x ∈ 0}.Pairwise AddCommute)
Goal: Multiset.noncommSum 0 h = 0
-- Multiset.noncommSum_cons
@[to_additive (attr := simp)]
theorem noncommProd_cons (s : Multiset α) (a : α) (comm) :
    noncommProd (a ::ₘ s) comm = a * noncommProd s (comm.mono fun _ => mem_cons_of_mem) 
Arguments: {α : Type u_3} [AddMonoid α] (s : Multiset α) (a : α) (comm : {x | x ∈ a ::ₘ s}.Pairwise AddCommute)
Goal: (a ::ₘ s).noncommSum comm = a + s.noncommSum ⋯
-- Multiset.noncommProd_cons
@[to_additive (attr := simp)]
theorem noncommProd_cons (s : Multiset α) (a : α) (comm) :
    noncommProd (a ::ₘ s) comm = a * noncommProd s (comm.mono fun _ => mem_cons_of_mem) 
Arguments: {α : Type u_3} [Monoid α] (s : Multiset α) (a : α) (comm : {x | x ∈ a ::ₘ s}.Pairwise Commute)
Goal: (a ::ₘ s).noncommProd comm = a * s.noncommProd ⋯
-- Multiset.noncommSum_cons'
@[to_additive]
theorem noncommProd_cons' (s : Multiset α) (a : α) (comm) :
    noncommProd (a ::ₘ s) comm = noncommProd s (comm.mono fun _ => mem_cons_of_mem) * a 
Arguments: {α : Type u_3} [AddMonoid α] (s : Multiset α) (a : α) (comm : {x | x ∈ a ::ₘ s}.Pairwise AddCommute)
Goal: (a ::ₘ s).noncommSum comm = s.noncommSum ⋯ + a
-- Multiset.noncommProd_cons'
@[to_additive]
theorem noncommProd_cons' (s : Multiset α) (a : α) (comm) :
    noncommProd (a ::ₘ s) comm = noncommProd s (comm.mono fun _ => mem_cons_of_mem) * a 
Arguments: {α : Type u_3} [Monoid α] (s : Multiset α) (a : α) (comm : {x | x ∈ a ::ₘ s}.Pairwise Commute)
Goal: (a ::ₘ s).noncommProd comm = s.noncommProd ⋯ * a
-- Multiset.noncommProd_add
@[to_additive]
theorem noncommProd_add (s t : Multiset α) (comm) :
    noncommProd (s + t) comm =
      noncommProd s (comm.mono <| subset_of_le <| s.le_add_right t) *
        noncommProd t (comm.mono <| subset_of_le <| t.le_add_left s) 
Arguments: {α : Type u_3} [Monoid α] (s t : Multiset α) (comm : {x | x ∈ s + t}.Pairwise Commute)
Goal: (s + t).noncommProd comm = s.noncommProd ⋯ * t.noncommProd ⋯
-- Multiset.noncommSum_add
@[to_additive]
theorem noncommProd_add (s t : Multiset α) (comm) :
    noncommProd (s + t) comm =
      noncommProd s (comm.mono <| subset_of_le <| s.le_add_right t) *
        noncommProd t (comm.mono <| subset_of_le <| t.le_add_left s) 
Arguments: {α : Type u_3} [AddMonoid α] (s t : Multiset α) (comm : {x | x ∈ s + t}.Pairwise AddCommute)
Goal: (s + t).noncommSum comm = s.noncommSum ⋯ + t.noncommSum ⋯
-- Multiset.noncommProd_induction
@[to_additive]
lemma noncommProd_induction (s : Multiset α) (comm)
    (p : α → Prop) (hom : ∀ a b, p a → p b → p (a * b)) (unit : p 1) (base : ∀ x ∈ s, p x) :
    p (s.noncommProd comm) 
Arguments: {α : Type u_3} [Monoid α] (s : Multiset α) (comm : {x | x ∈ s}.Pairwise Commute) (p : α → Prop) (hom : ∀ (a b : α), p a → p b → p (a * b)) (unit : p 1) (base : ∀ x ∈ s, p x)
Goal: p (s.noncommProd comm)
-- Multiset.noncommSum_induction
@[to_additive]
lemma noncommProd_induction (s : Multiset α) (comm)
    (p : α → Prop) (hom : ∀ a b, p a → p b → p (a * b)) (unit : p 1) (base : ∀ x ∈ s, p x) :
    p (s.noncommProd comm) 
Arguments: {α : Type u_3} [AddMonoid α] (s : Multiset α) (comm : {x | x ∈ s}.Pairwise AddCommute) (p : α → Prop) (hom : ∀ (a b : α), p a → p b → p (a + b)) (unit : p 0) (base : ∀ x ∈ s, p x)
Goal: p (s.noncommSum comm)
-- Multiset.map_noncommSum_aux
@[to_additive]
protected theorem map_noncommProd_aux [MonoidHomClass F α β] (s : Multiset α)
    (comm : { x | x ∈ s }.Pairwise Commute) (f : F) : { x | x ∈ s.map f }.Pairwise Commute 
Arguments: {F : Type u_1} {α : Type u_3} {β : Type u_4} [AddMonoid α] [AddMonoid β] [FunLike F α β] [AddMonoidHomClass F α β] (s : Multiset α) (comm : {x | x ∈ s}.Pairwise AddCommute) (f : F)
Goal: {x | x ∈ Multiset.map (⇑f) s}.Pairwise AddCommute
-- Multiset.map_noncommProd_aux
@[to_additive]
protected theorem map_noncommProd_aux [MonoidHomClass F α β] (s : Multiset α)
    (comm : { x | x ∈ s }.Pairwise Commute) (f : F) : { x | x ∈ s.map f }.Pairwise Commute 
Arguments: {F : Type u_1} {α : Type u_3} {β : Type u_4} [Monoid α] [Monoid β] [FunLike F α β] [MonoidHomClass F α β] (s : Multiset α) (comm : {x | x ∈ s}.Pairwise Commute) (f : F)
Goal: {x | x ∈ Multiset.map (⇑f) s}.Pairwise Commute
-- Multiset.map_noncommSum
@[to_additive]
theorem map_noncommProd [MonoidHomClass F α β] (s : Multiset α) (comm) (f : F) :
    f (s.noncommProd comm) = (s.map f).noncommProd (Multiset.map_noncommProd_aux s comm f) 
Arguments: {F : Type u_1} {α : Type u_3} {β : Type u_4} [AddMonoid α] [AddMonoid β] [FunLike F α β] [AddMonoidHomClass F α β] (s : Multiset α) (comm : {x | x ∈ s}.Pairwise AddCommute) (f : F)
Goal: f (s.noncommSum comm) = (Multiset.map (⇑f) s).noncommSum ⋯
-- Multiset.map_noncommProd
@[to_additive]
theorem map_noncommProd [MonoidHomClass F α β] (s : Multiset α) (comm) (f : F) :
    f (s.noncommProd comm) = (s.map f).noncommProd (Multiset.map_noncommProd_aux s comm f) 
Arguments: {F : Type u_1} {α : Type u_3} {β : Type u_4} [Monoid α] [Monoid β] [FunLike F α β] [MonoidHomClass F α β] (s : Multiset α) (comm : {x | x ∈ s}.Pairwise Commute) (f : F)
Goal: f (s.noncommProd comm) = (Multiset.map (⇑f) s).noncommProd ⋯
-- Multiset.noncommProd_eq_pow_card
@[to_additive noncommSum_eq_card_nsmul]
theorem noncommProd_eq_pow_card (s : Multiset α) (comm) (m : α) (h : ∀ x ∈ s, x = m) :
    s.noncommProd comm = m ^ Multiset.card s 
Arguments: {α : Type u_3} [Monoid α] (s : Multiset α) (comm : {x | x ∈ s}.Pairwise Commute) (m : α) (h : ∀ x ∈ s, x = m)
Goal: s.noncommProd comm = m ^ Multiset.card s
-- Multiset.noncommSum_eq_card_nsmul
@[to_additive noncommSum_eq_card_nsmul]
theorem noncommProd_eq_pow_card (s : Multiset α) (comm) (m : α) (h : ∀ x ∈ s, x = m) :
    s.noncommProd comm = m ^ Multiset.card s 
Arguments: {α : Type u_3} [AddMonoid α] (s : Multiset α) (comm : {x | x ∈ s}.Pairwise AddCommute) (m : α) (h : ∀ x ∈ s, x = m)
Goal: s.noncommSum comm = Multiset.card s • m
-- Multiset.noncommProd_eq_prod
@[to_additive]
theorem noncommProd_eq_prod {α : Type*} [CommMonoid α] (s : Multiset α) :
    (noncommProd s fun _ _ _ _ _ => Commute.all _ _) = prod s 
Arguments: {α : Type u_6} [CommMonoid α] (s : Multiset α)
Goal: s.noncommProd ⋯ = s.prod
-- Multiset.noncommSum_eq_sum
@[to_additive]
theorem noncommProd_eq_prod {α : Type*} [CommMonoid α] (s : Multiset α) :
    (noncommProd s fun _ _ _ _ _ => Commute.all _ _) = prod s 
Arguments: {α : Type u_6} [AddCommMonoid α] (s : Multiset α)
Goal: s.noncommSum ⋯ = s.sum
-- Multiset.noncommSum_addCommute
@[to_additive]
theorem noncommProd_commute (s : Multiset α) (comm) (y : α) (h : ∀ x ∈ s, Commute y x) :
    Commute y (s.noncommProd comm) 
Arguments: {α : Type u_3} [AddMonoid α] (s : Multiset α) (comm : {x | x ∈ s}.Pairwise AddCommute) (y : α) (h : ∀ x ∈ s, AddCommute y x)
Goal: AddCommute y (s.noncommSum comm)
-- Multiset.noncommProd_commute
@[to_additive]
theorem noncommProd_commute (s : Multiset α) (comm) (y : α) (h : ∀ x ∈ s, Commute y x) :
    Commute y (s.noncommProd comm) 
Arguments: {α : Type u_3} [Monoid α] (s : Multiset α) (comm : {x | x ∈ s}.Pairwise Commute) (y : α) (h : ∀ x ∈ s, Commute y x)
Goal: Commute y (s.noncommProd comm)
-- Multiset.mul_noncommProd_erase
theorem mul_noncommProd_erase [DecidableEq α] (s : Multiset α) {a : α} (h : a ∈ s) (comm)
    (comm' := fun x hx y hy hxy ↦ comm (s.mem_of_mem_erase hx) (s.mem_of_mem_erase hy) hxy) :
    a * (s.erase a).noncommProd comm' = s.noncommProd comm 
Arguments: {α : Type u_3} [Monoid α] [DecidableEq α] (s : Multiset α) {a : α} (h : a ∈ s) (comm : {x | x ∈ s}.Pairwise Commute) (comm' : ∀ x ∈ {x | x ∈ s.erase a}, ∀ y ∈ {x | x ∈ s.erase a}, x ≠ y → Commute x y := ⋯)
Goal: a * (s.erase a).noncommProd comm' = s.noncommProd comm
-- Multiset.noncommProd_erase_mul
theorem noncommProd_erase_mul [DecidableEq α] (s : Multiset α) {a : α} (h : a ∈ s) (comm)
    (comm' := fun x hx y hy hxy ↦ comm (s.mem_of_mem_erase hx) (s.mem_of_mem_erase hy) hxy) :
    (s.erase a).noncommProd comm' * a = s.noncommProd comm 
Arguments: {α : Type u_3} [Monoid α] [DecidableEq α] (s : Multiset α) {a : α} (h : a ∈ s) (comm : {x | x ∈ s}.Pairwise Commute) (comm' : ∀ x ∈ {x | x ∈ s.erase a}, ∀ y ∈ {x | x ∈ s.erase a}, x ≠ y → Commute x y := ⋯)
Goal: (s.erase a).noncommProd comm' * a = s.noncommProd comm
-- Finset.noncommProd_lemma
@[to_additive]
theorem noncommProd_lemma (s : Finset α) (f : α → β)
    (comm : (s : Set α).Pairwise fun a b => Commute (f a) (f b)) :
    Set.Pairwise { x | x ∈ Multiset.map f s.val } Commute 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] (s : Finset α) (f : α → β) (comm : (↑s).Pairwise fun a b => Commute (f a) (f b))
Goal: {x | x ∈ Multiset.map f s.val}.Pairwise Commute
-- Finset.noncommSum_lemma
@[to_additive]
theorem noncommProd_lemma (s : Finset α) (f : α → β)
    (comm : (s : Set α).Pairwise fun a b => Commute (f a) (f b)) :
    Set.Pairwise { x | x ∈ Multiset.map f s.val } Commute 
Arguments: {α : Type u_3} {β : Type u_4} [AddMonoid β] (s : Finset α) (f : α → β) (comm : (↑s).Pairwise fun a b => AddCommute (f a) (f b))
Goal: {x | x ∈ Multiset.map f s.val}.Pairwise AddCommute
-- Finset.noncommProd_induction
@[to_additive]
lemma noncommProd_induction (s : Finset α) (f : α → β) (comm)
    (p : β → Prop) (hom : ∀ a b, p a → p b → p (a * b)) (unit : p 1) (base : ∀ x ∈ s, p (f x)) :
    p (s.noncommProd f comm) 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] (s : Finset α) (f : α → β) (comm : (↑s).Pairwise fun a b => Commute (f a) (f b)) (p : β → Prop) (hom : ∀ (a b : β), p a → p b → p (a * b)) (unit : p 1) (base : ∀ x ∈ s, p (f x))
Goal: p (s.noncommProd f comm)
-- Finset.noncommSum_induction
@[to_additive]
lemma noncommProd_induction (s : Finset α) (f : α → β) (comm)
    (p : β → Prop) (hom : ∀ a b, p a → p b → p (a * b)) (unit : p 1) (base : ∀ x ∈ s, p (f x)) :
    p (s.noncommProd f comm) 
Arguments: {α : Type u_3} {β : Type u_4} [AddMonoid β] (s : Finset α) (f : α → β) (comm : (↑s).Pairwise fun a b => AddCommute (f a) (f b)) (p : β → Prop) (hom : ∀ (a b : β), p a → p b → p (a + b)) (unit : p 0) (base : ∀ x ∈ s, p (f x))
Goal: p (s.noncommSum f comm)
-- Finset.noncommProd_congr
@[to_additive (attr := congr)]
theorem noncommProd_congr {s₁ s₂ : Finset α} {f g : α → β} (h₁ : s₁ = s₂)
    (h₂ : ∀ x ∈ s₂, f x = g x) (comm) :
    noncommProd s₁ f comm =
      noncommProd s₂ g fun x hx y hy h => by
        dsimp only
        rw [← h₂ _ hx, ← h₂ _ hy]
        subst h₁
        exact comm hx hy h 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] {s₁ s₂ : Finset α} {f g : α → β} (h₁ : s₁ = s₂) (h₂ : ∀ x ∈ s₂, f x = g x) (comm : (↑s₁).Pairwise fun a b => Commute (f a) (f b))
Goal: s₁.noncommProd f comm = s₂.noncommProd g ⋯
-- Finset.noncommSum_congr
@[to_additive (attr := congr)]
theorem noncommProd_congr {s₁ s₂ : Finset α} {f g : α → β} (h₁ : s₁ = s₂)
    (h₂ : ∀ x ∈ s₂, f x = g x) (comm) :
    noncommProd s₁ f comm =
      noncommProd s₂ g fun x hx y hy h => by
        dsimp only
        rw [← h₂ _ hx, ← h₂ _ hy]
        subst h₁
        exact comm hx hy h 
Arguments: {α : Type u_3} {β : Type u_4} [AddMonoid β] {s₁ s₂ : Finset α} {f g : α → β} (h₁ : s₁ = s₂) (h₂ : ∀ x ∈ s₂, f x = g x) (comm : (↑s₁).Pairwise fun a b => AddCommute (f a) (f b))
Goal: s₁.noncommSum f comm = s₂.noncommSum g ⋯
-- Finset.noncommSum_toFinset
@[to_additive (attr := simp)]
theorem noncommProd_toFinset [DecidableEq α] (l : List α) (f : α → β) (comm) (hl : l.Nodup) :
    noncommProd l.toFinset f comm = (l.map f).prod 
Arguments: {α : Type u_3} {β : Type u_4} [AddMonoid β] [DecidableEq α] (l : List α) (f : α → β) (comm : (↑l.toFinset).Pairwise fun a b => AddCommute (f a) (f b)) (hl : l.Nodup)
Goal: l.toFinset.noncommSum f comm = (List.map f l).sum
-- Finset.noncommProd_toFinset
@[to_additive (attr := simp)]
theorem noncommProd_toFinset [DecidableEq α] (l : List α) (f : α → β) (comm) (hl : l.Nodup) :
    noncommProd l.toFinset f comm = (l.map f).prod 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] [DecidableEq α] (l : List α) (f : α → β) (comm : (↑l.toFinset).Pairwise fun a b => Commute (f a) (f b)) (hl : l.Nodup)
Goal: l.toFinset.noncommProd f comm = (List.map f l).prod
-- Finset.noncommSum_empty
@[to_additive (attr := simp)]
theorem noncommProd_empty (f : α → β) (h) : noncommProd (∅ : Finset α) f h = 1 
Arguments: {α : Type u_3} {β : Type u_4} [AddMonoid β] (f : α → β) (h : (↑∅).Pairwise fun a b => AddCommute (f a) (f b))
Goal: ∅.noncommSum f h = 0
-- Finset.noncommProd_empty
@[to_additive (attr := simp)]
theorem noncommProd_empty (f : α → β) (h) : noncommProd (∅ : Finset α) f h = 1 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] (f : α → β) (h : (↑∅).Pairwise fun a b => Commute (f a) (f b))
Goal: ∅.noncommProd f h = 1
-- Finset.noncommSum_cons
@[to_additive (attr := simp)]
theorem noncommProd_cons (s : Finset α) (a : α) (f : α → β)
    (ha : a ∉ s) (comm) :
    noncommProd (cons a s ha) f comm =
      f a * noncommProd s f (comm.mono fun _ => Finset.mem_cons.2 ∘ .inr) 
Arguments: {α : Type u_3} {β : Type u_4} [AddMonoid β] (s : Finset α) (a : α) (f : α → β) (ha : a ∉ s) (comm : (↑(Finset.cons a s ha)).Pairwise fun a b => AddCommute (f a) (f b))
Goal: (Finset.cons a s ha).noncommSum f comm = f a + s.noncommSum f ⋯