ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finsupp.zero_not_mem_frange
theorem zero_not_mem_frange {f : α →₀ M} : (0 : M) ∉ f.frange 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {f : α →₀ M}
Goal: 0 ∉ f.frange
-- Finsupp.frange_single
theorem frange_single {x : α} {y : M} : frange (single x y) ⊆ {y} 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {x : α} {y : M}
Goal: (Finsupp.single x y).frange ⊆ {y}
-- Finsupp.support_subtypeDomain
@[simp]
theorem support_subtypeDomain [D : DecidablePred p] {f : α →₀ M} :
    (subtypeDomain p f).support = f.support.subtype p 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {p : α → Prop} [D : DecidablePred p] {f : α →₀ M}
Goal: (Finsupp.subtypeDomain p f).support = Finset.subtype p f.support
-- Finsupp.subtypeDomain_apply
@[simp]
theorem subtypeDomain_apply {a : Subtype p} {v : α →₀ M} : (subtypeDomain p v) a = v a.val 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {p : α → Prop} {a : Subtype p} {v : α →₀ M}
Goal: (Finsupp.subtypeDomain p v) a = v ↑a
-- Finsupp.subtypeDomain_zero
@[simp]
theorem subtypeDomain_zero : subtypeDomain p (0 : α →₀ M) = 0 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {p : α → Prop}
Goal: Finsupp.subtypeDomain p 0 = 0
-- Finsupp.subtypeDomain_eq_zero_iff'
theorem subtypeDomain_eq_zero_iff' {f : α →₀ M} : f.subtypeDomain p = 0 ↔ ∀ x, p x → f x = 0 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {p : α → Prop} {f : α →₀ M}
Goal: Finsupp.subtypeDomain p f = 0 ↔ ∀ (x : α), p x → f x = 0
-- Finsupp.subtypeDomain_eq_zero_iff
theorem subtypeDomain_eq_zero_iff {f : α →₀ M} (hf : ∀ x ∈ f.support, p x) :
    f.subtypeDomain p = 0 ↔ f = 0 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {p : α → Prop} {f : α →₀ M} (hf : ∀ x ∈ f.support, p x)
Goal: Finsupp.subtypeDomain p f = 0 ↔ f = 0
-- Finsupp.sum_subtypeDomain_index
@[to_additive]
theorem prod_subtypeDomain_index [CommMonoid N] {v : α →₀ M} {h : α → M → N}
    (hp : ∀ x ∈ v.support, p x) : (v.subtypeDomain p).prod (fun a b ↦ h a b) = v.prod h 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [Zero M] {p : α → Prop} [AddCommMonoid N] {v : α →₀ M} {h : α → M → N} (hp : ∀ x ∈ v.support, p x)
Goal: ((Finsupp.subtypeDomain p v).sum fun a b => h (↑a) b) = v.sum h
-- Finsupp.prod_subtypeDomain_index
@[to_additive]
theorem prod_subtypeDomain_index [CommMonoid N] {v : α →₀ M} {h : α → M → N}
    (hp : ∀ x ∈ v.support, p x) : (v.subtypeDomain p).prod (fun a b ↦ h a b) = v.prod h 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [Zero M] {p : α → Prop} [CommMonoid N] {v : α →₀ M} {h : α → M → N} (hp : ∀ x ∈ v.support, p x)
Goal: ((Finsupp.subtypeDomain p v).prod fun a b => h (↑a) b) = v.prod h
-- Finsupp.subtypeDomain_add
@[simp]
theorem subtypeDomain_add {v v' : α →₀ M} :
    (v + v').subtypeDomain p = v.subtypeDomain p + v'.subtypeDomain p 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] {p : α → Prop} {v v' : α →₀ M}
Goal: Finsupp.subtypeDomain p (v + v') = Finsupp.subtypeDomain p v + Finsupp.subtypeDomain p v'
-- Finsupp.filter_add
@[simp]
theorem filter_add [DecidablePred p] {v v' : α →₀ M} :
    (v + v').filter p = v.filter p + v'.filter p 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] {p : α → Prop} [DecidablePred p] {v v' : α →₀ M}
Goal: Finsupp.filter p (v + v') = Finsupp.filter p v + Finsupp.filter p v'
-- Finsupp.subtypeDomain_sum
theorem subtypeDomain_sum {s : Finset ι} {h : ι → α →₀ M} :
    (∑ c ∈ s, h c).subtypeDomain p = ∑ c ∈ s, (h c).subtypeDomain p 
Arguments: {α : Type u_1} {ι : Type u_4} {M : Type u_5} [AddCommMonoid M] {p : α → Prop} {s : Finset ι} {h : ι → α →₀ M}
Goal: Finsupp.subtypeDomain p (∑ c ∈ s, h c) = ∑ c ∈ s, Finsupp.subtypeDomain p (h c)
-- Finsupp.subtypeDomain_finsupp_sum
theorem subtypeDomain_finsupp_sum [Zero N] {s : β →₀ N} {h : β → N → α →₀ M} :
    (s.sum h).subtypeDomain p = s.sum fun c d => (h c d).subtypeDomain p 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] {p : α → Prop} [Zero N] {s : β →₀ N} {h : β → N → α →₀ M}
Goal: Finsupp.subtypeDomain p (s.sum h) = s.sum fun c d => Finsupp.subtypeDomain p (h c d)
-- Finsupp.filter_sum
theorem filter_sum [DecidablePred p] (s : Finset ι) (f : ι → α →₀ M) :
    (∑ a ∈ s, f a).filter p = ∑ a ∈ s, filter p (f a) 
Arguments: {α : Type u_1} {ι : Type u_4} {M : Type u_5} [AddCommMonoid M] {p : α → Prop} [DecidablePred p] (s : Finset ι) (f : ι → α →₀ M)
Goal: Finsupp.filter p (∑ a ∈ s, f a) = ∑ a ∈ s, Finsupp.filter p (f a)
-- Finsupp.filter_eq_sum
theorem filter_eq_sum (p : α → Prop) [DecidablePred p] (f : α →₀ M) :
    f.filter p = ∑ i ∈ f.support.filter p, single i (f i) 
Arguments: {α : Type u_1} {M : Type u_5} [AddCommMonoid M] (p : α → Prop) [DecidablePred p] (f : α →₀ M)
Goal: Finsupp.filter p f = ∑ i ∈ Finset.filter p f.support, Finsupp.single i (f i)
-- Finsupp.subtypeDomain_neg
@[simp]
theorem subtypeDomain_neg : (-v).subtypeDomain p = -v.subtypeDomain p 
Arguments: {α : Type u_1} {G : Type u_9} [AddGroup G] {p : α → Prop} {v : α →₀ G}
Goal: Finsupp.subtypeDomain p (-v) = -Finsupp.subtypeDomain p v
-- Finsupp.subtypeDomain_sub
@[simp]
theorem subtypeDomain_sub : (v - v').subtypeDomain p = v.subtypeDomain p - v'.subtypeDomain p 
Arguments: {α : Type u_1} {G : Type u_9} [AddGroup G] {p : α → Prop} {v v' : α →₀ G}
Goal: Finsupp.subtypeDomain p (v - v') = Finsupp.subtypeDomain p v - Finsupp.subtypeDomain p v'
-- Finsupp.single_neg
@[simp]
theorem single_neg (a : α) (b : G) : single a (-b) = -single a b 
Arguments: {α : Type u_1} {G : Type u_9} [AddGroup G] (a : α) (b : G)
Goal: Finsupp.single a (-b) = -Finsupp.single a b
-- Finsupp.single_sub
@[simp]
theorem single_sub (a : α) (b₁ b₂ : G) : single a (b₁ - b₂) = single a b₁ - single a b₂ 
Arguments: {α : Type u_1} {G : Type u_9} [AddGroup G] (a : α) (b₁ b₂ : G)
Goal: Finsupp.single a (b₁ - b₂) = Finsupp.single a b₁ - Finsupp.single a b₂
-- Finsupp.erase_neg
@[simp]
theorem erase_neg (a : α) (f : α →₀ G) : erase a (-f) = -erase a f 
Arguments: {α : Type u_1} {G : Type u_9} [AddGroup G] (a : α) (f : α →₀ G)
Goal: Finsupp.erase a (-f) = -Finsupp.erase a f
-- Finsupp.erase_sub
@[simp]
theorem erase_sub (a : α) (f₁ f₂ : α →₀ G) : erase a (f₁ - f₂) = erase a f₁ - erase a f₂ 
Arguments: {α : Type u_1} {G : Type u_9} [AddGroup G] (a : α) (f₁ f₂ : α →₀ G)
Goal: Finsupp.erase a (f₁ - f₂) = Finsupp.erase a f₁ - Finsupp.erase a f₂
-- Finsupp.filter_neg
@[simp]
theorem filter_neg (p : α → Prop) [DecidablePred p] (f : α →₀ G) : filter p (-f) = -filter p f 
Arguments: {α : Type u_1} {G : Type u_9} [AddGroup G] (p : α → Prop) [DecidablePred p] (f : α →₀ G)
Goal: Finsupp.filter p (-f) = -Finsupp.filter p f
-- Finsupp.filter_sub
@[simp]
theorem filter_sub (p : α → Prop) [DecidablePred p] (f₁ f₂ : α →₀ G) :
    filter p (f₁ - f₂) = filter p f₁ - filter p f₂ 
Arguments: {α : Type u_1} {G : Type u_9} [AddGroup G] (p : α → Prop) [DecidablePred p] (f₁ f₂ : α →₀ G)
Goal: Finsupp.filter p (f₁ - f₂) = Finsupp.filter p f₁ - Finsupp.filter p f₂
-- Finsupp.mem_support_multiset_sum
theorem mem_support_multiset_sum [AddCommMonoid M] {s : Multiset (α →₀ M)} (a : α) :
    a ∈ s.sum.support → ∃ f ∈ s, a ∈ (f : α →₀ M).support 
Arguments: {α : Type u_1} {M : Type u_5} [AddCommMonoid M] {s : Multiset (α →₀ M)} (a : α)
Goal: a ∈ s.sum.support → ∃ f ∈ s, a ∈ f.support
-- Finsupp.mem_support_finset_sum
theorem mem_support_finset_sum [AddCommMonoid M] {s : Finset ι} {h : ι → α →₀ M} (a : α)
    (ha : a ∈ (∑ c ∈ s, h c).support) : ∃ c ∈ s, a ∈ (h c).support 
Arguments: {α : Type u_1} {ι : Type u_4} {M : Type u_5} [AddCommMonoid M] {s : Finset ι} {h : ι → α →₀ M} (a : α) (ha : a ∈ (∑ c ∈ s, h c).support)
Goal: ∃ c ∈ s, a ∈ (h c).support
-- Finsupp.curry_apply
@[simp]
theorem curry_apply (f : α × β →₀ M) (x : α) (y : β) : f.curry x y = f (x, y) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] (f : α × β →₀ M) (x : α) (y : β)
Goal: (f.curry x) y = f (x, y)
-- Finsupp.sum_curry_index
theorem sum_curry_index (f : α × β →₀ M) (g : α → β → M → N) (hg₀ : ∀ a b, g a b 0 = 0)
    (hg₁ : ∀ a b c₀ c₁, g a b (c₀ + c₁) = g a b c₀ + g a b c₁) :
    (f.curry.sum fun a f => f.sum (g a)) = f.sum fun p c => g p.1 p.2 c 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [AddCommMonoid N] (f : α × β →₀ M) (g : α → β → M → N) (hg₀ : ∀ (a : α) (b : β), g a b 0 = 0) (hg₁ : ∀ (a : α) (b : β) (c₀ c₁ : M), g a b (c₀ + c₁) = g a b c₀ + g a b c₁)
Goal: (f.curry.sum fun a f => f.sum (g a)) = f.sum fun p c => g p.1 p.2 c
-- Finsupp.filter_curry
theorem filter_curry (f : α × β →₀ M) (p : α → Prop) [DecidablePred p] :
    (f.filter fun a : α × β => p a.1).curry = f.curry.filter p 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] (f : α × β →₀ M) (p : α → Prop) [DecidablePred p]
Goal: (Finsupp.filter (fun a => p a.1) f).curry = Finsupp.filter p f.curry
-- Finsupp.support_curry
theorem support_curry [DecidableEq α] (f : α × β →₀ M) :
    f.curry.support ⊆ f.support.image Prod.fst 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] [DecidableEq α] (f : α × β →₀ M)
Goal: f.curry.support ⊆ Finset.image Prod.fst f.support
-- Finsupp.coe_sumElim
@[simp, norm_cast]
theorem coe_sumElim {α β γ : Type*} [Zero γ] (f : α →₀ γ) (g : β →₀ γ) :
    ⇑(sumElim f g) = Sum.elim f g 
Arguments: {α : Type u_13} {β : Type u_14} {γ : Type u_15} [Zero γ] (f : α →₀ γ) (g : β →₀ γ)
Goal: ⇑(f.sumElim g) = Sum.elim ⇑f ⇑g
-- Finsupp.sumElim_apply
theorem sumElim_apply {α β γ : Type*} [Zero γ] (f : α →₀ γ) (g : β →₀ γ) (x : α ⊕ β) :
    sumElim f g x = Sum.elim f g x 
Arguments: {α : Type u_13} {β : Type u_14} {γ : Type u_15} [Zero γ] (f : α →₀ γ) (g : β →₀ γ) (x : α ⊕ β)
Goal: (f.sumElim g) x = Sum.elim (⇑f) (⇑g) x
-- Finsupp.sumElim_inl
theorem sumElim_inl {α β γ : Type*} [Zero γ] (f : α →₀ γ) (g : β →₀ γ) (x : α) :
    sumElim f g (Sum.inl x) = f x 
Arguments: {α : Type u_13} {β : Type u_14} {γ : Type u_15} [Zero γ] (f : α →₀ γ) (g : β →₀ γ) (x : α)
Goal: (f.sumElim g) (Sum.inl x) = f x
-- Finsupp.sumElim_inr
theorem sumElim_inr {α β γ : Type*} [Zero γ] (f : α →₀ γ) (g : β →₀ γ) (x : β) :
    sumElim f g (Sum.inr x) = g x 
Arguments: {α : Type u_13} {β : Type u_14} {γ : Type u_15} [Zero γ] (f : α →₀ γ) (g : β →₀ γ) (x : β)
Goal: (f.sumElim g) (Sum.inr x) = g x
-- Finsupp.sumFinsuppEquivProdFinsupp_symm_apply
@[simps apply symm_apply]
def sumFinsuppEquivProdFinsupp {α β γ : Type*} [Zero γ] : (α ⊕ β →₀ γ) ≃ (α →₀ γ) × (β →₀ γ) 
Arguments: {α : Type u_13} {β : Type u_14} {γ : Type u_15} [Zero γ] (fg : (α →₀ γ) × (β →₀ γ))
Goal: Finsupp.sumFinsuppEquivProdFinsupp.symm fg = fg.1.sumElim fg.2
-- Finsupp.sumFinsuppEquivProdFinsupp_apply
@[simps apply symm_apply]
def sumFinsuppEquivProdFinsupp {α β γ : Type*} [Zero γ] : (α ⊕ β →₀ γ) ≃ (α →₀ γ) × (β →₀ γ) 
Arguments: {α : Type u_13} {β : Type u_14} {γ : Type u_15} [Zero γ] (f : α ⊕ β →₀ γ)
Goal: Finsupp.sumFinsuppEquivProdFinsupp f = (Finsupp.comapDomain Sum.inl f ⋯, Finsupp.comapDomain Sum.inr f ⋯)
-- Finsupp.fst_sumFinsuppEquivProdFinsupp
theorem fst_sumFinsuppEquivProdFinsupp {α β γ : Type*} [Zero γ] (f : α ⊕ β →₀ γ) (x : α) :
    (sumFinsuppEquivProdFinsupp f).1 x = f (Sum.inl x) 
Arguments: {α : Type u_13} {β : Type u_14} {γ : Type u_15} [Zero γ] (f : α ⊕ β →₀ γ) (x : α)
Goal: (Finsupp.sumFinsuppEquivProdFinsupp f).1 x = f (Sum.inl x)
-- Finsupp.snd_sumFinsuppEquivProdFinsupp
theorem snd_sumFinsuppEquivProdFinsupp {α β γ : Type*} [Zero γ] (f : α ⊕ β →₀ γ) (y : β) :
    (sumFinsuppEquivProdFinsupp f).2 y = f (Sum.inr y) 
Arguments: {α : Type u_13} {β : Type u_14} {γ : Type u_15} [Zero γ] (f : α ⊕ β →₀ γ) (y : β)
Goal: (Finsupp.sumFinsuppEquivProdFinsupp f).2 y = f (Sum.inr y)
-- Finsupp.sumFinsuppEquivProdFinsupp_symm_inl
theorem sumFinsuppEquivProdFinsupp_symm_inl {α β γ : Type*} [Zero γ] (fg : (α →₀ γ) × (β →₀ γ))
    (x : α) : (sumFinsuppEquivProdFinsupp.symm fg) (Sum.inl x) = fg.1 x 
Arguments: {α : Type u_13} {β : Type u_14} {γ : Type u_15} [Zero γ] (fg : (α →₀ γ) × (β →₀ γ)) (x : α)
Goal: (Finsupp.sumFinsuppEquivProdFinsupp.symm fg) (Sum.inl x) = fg.1 x
-- Finsupp.sumFinsuppEquivProdFinsupp_symm_inr
theorem sumFinsuppEquivProdFinsupp_symm_inr {α β γ : Type*} [Zero γ] (fg : (α →₀ γ) × (β →₀ γ))
    (y : β) : (sumFinsuppEquivProdFinsupp.symm fg) (Sum.inr y) = fg.2 y 
Arguments: {α : Type u_13} {β : Type u_14} {γ : Type u_15} [Zero γ] (fg : (α →₀ γ) × (β →₀ γ)) (y : β)
Goal: (Finsupp.sumFinsuppEquivProdFinsupp.symm fg) (Sum.inr y) = fg.2 y
-- Finsupp.sumFinsuppAddEquivProdFinsupp_apply
@[simps! apply symm_apply]
def sumFinsuppAddEquivProdFinsupp {α β : Type*} : (α ⊕ β →₀ M) ≃+ (α →₀ M) × (β →₀ M) 
Arguments: {M : Type u_5} [AddMonoid M] {α : Type u_13} {β : Type u_14} (f : α ⊕ β →₀ M)
Goal: Finsupp.sumFinsuppAddEquivProdFinsupp f = (Finsupp.comapDomain Sum.inl f ⋯, Finsupp.comapDomain Sum.inr f ⋯)
-- Finsupp.sumFinsuppAddEquivProdFinsupp_symm_apply
@[simps! apply symm_apply]
def sumFinsuppAddEquivProdFinsupp {α β : Type*} : (α ⊕ β →₀ M) ≃+ (α →₀ M) × (β →₀ M) 
Arguments: {M : Type u_5} [AddMonoid M] {α : Type u_13} {β : Type u_14} (fg : (α →₀ M) × (β →₀ M))
Goal: Finsupp.sumFinsuppAddEquivProdFinsupp.symm fg = fg.1.sumElim fg.2
-- Finsupp.fst_sumFinsuppAddEquivProdFinsupp
theorem fst_sumFinsuppAddEquivProdFinsupp {α β : Type*} (f : α ⊕ β →₀ M) (x : α) :
    (sumFinsuppAddEquivProdFinsupp f).1 x = f (Sum.inl x) 
Arguments: {M : Type u_5} [AddMonoid M] {α : Type u_13} {β : Type u_14} (f : α ⊕ β →₀ M) (x : α)
Goal: (Finsupp.sumFinsuppAddEquivProdFinsupp f).1 x = f (Sum.inl x)
-- Finsupp.snd_sumFinsuppAddEquivProdFinsupp
theorem snd_sumFinsuppAddEquivProdFinsupp {α β : Type*} (f : α ⊕ β →₀ M) (y : β) :
    (sumFinsuppAddEquivProdFinsupp f).2 y = f (Sum.inr y) 
Arguments: {M : Type u_5} [AddMonoid M] {α : Type u_13} {β : Type u_14} (f : α ⊕ β →₀ M) (y : β)
Goal: (Finsupp.sumFinsuppAddEquivProdFinsupp f).2 y = f (Sum.inr y)
-- Finsupp.sumFinsuppAddEquivProdFinsupp_symm_inl
theorem sumFinsuppAddEquivProdFinsupp_symm_inl {α β : Type*} (fg : (α →₀ M) × (β →₀ M)) (x : α) :
    (sumFinsuppAddEquivProdFinsupp.symm fg) (Sum.inl x) = fg.1 x 
Arguments: {M : Type u_5} [AddMonoid M] {α : Type u_13} {β : Type u_14} (fg : (α →₀ M) × (β →₀ M)) (x : α)
Goal: (Finsupp.sumFinsuppAddEquivProdFinsupp.symm fg) (Sum.inl x) = fg.1 x
-- Finsupp.sumFinsuppAddEquivProdFinsupp_symm_inr
theorem sumFinsuppAddEquivProdFinsupp_symm_inr {α β : Type*} (fg : (α →₀ M) × (β →₀ M)) (y : β) :
    (sumFinsuppAddEquivProdFinsupp.symm fg) (Sum.inr y) = fg.2 y 
Arguments: {M : Type u_5} [AddMonoid M] {α : Type u_13} {β : Type u_14} (fg : (α →₀ M) × (β →₀ M)) (y : β)
Goal: (Finsupp.sumFinsuppAddEquivProdFinsupp.symm fg) (Sum.inr y) = fg.2 y
-- Finsupp.single_smul
@[simp, nolint simpNF] -- `simpNF` incorrectly complains the LHS doesn't simplify.
theorem single_smul (a b : α) (f : α → M) (r : R) : single a r b • f a = single a (r • f b) b 
Arguments: {α : Type u_1} {M : Type u_5} {R : Type u_11} [Zero M] [MonoidWithZero R] [MulActionWithZero R M] (a b : α) (f : α → M) (r : R)
Goal: (Finsupp.single a r) b • f a = (Finsupp.single a (r • f b)) b
-- Finsupp.comapSMul_def
theorem comapSMul_def (g : G) (f : α →₀ M) : g • f = mapDomain (g • ·) f 
Arguments: {α : Type u_1} {M : Type u_5} {G : Type u_9} [Monoid G] [MulAction G α] [AddCommMonoid M] (g : G) (f : α →₀ M)
Goal: g • f = Finsupp.mapDomain (fun x => g • x) f
-- Finsupp.comapSMul_single
@[simp]
theorem comapSMul_single (g : G) (a : α) (b : M) : g • single a b = single (g • a) b 
Arguments: {α : Type u_1} {M : Type u_5} {G : Type u_9} [Monoid G] [MulAction G α] [AddCommMonoid M] (g : G) (a : α) (b : M)
Goal: g • Finsupp.single a b = Finsupp.single (g • a) b
-- Finsupp.comapSMul_apply
@[simp]
theorem comapSMul_apply (g : G) (f : α →₀ M) (a : α) : (g • f) a = f (g⁻¹ • a) 
Arguments: {α : Type u_1} {M : Type u_5} {G : Type u_9} [Group G] [MulAction G α] [AddCommMonoid M] (g : G) (f : α →₀ M) (a : α)
Goal: (g • f) a = f (g⁻¹ • a)
-- Finsupp.coe_smul
@[simp, norm_cast]
theorem coe_smul [Zero M] [SMulZeroClass R M] (b : R) (v : α →₀ M) : ⇑(b • v) = b • ⇑v 
Arguments: {α : Type u_1} {M : Type u_5} {R : Type u_11} [Zero M] [SMulZeroClass R M] (b : R) (v : α →₀ M)
Goal: ⇑(b • v) = b • ⇑v
-- Finsupp.smul_apply
theorem smul_apply [Zero M] [SMulZeroClass R M] (b : R) (v : α →₀ M) (a : α) :
    (b • v) a = b • v a 
Arguments: {α : Type u_1} {M : Type u_5} {R : Type u_11} [Zero M] [SMulZeroClass R M] (b : R) (v : α →₀ M) (a : α)
Goal: (b • v) a = b • v a
-- IsSMulRegular.finsupp
theorem _root_.IsSMulRegular.finsupp [Zero M] [SMulZeroClass R M] {k : R}
    (hk : IsSMulRegular M k) : IsSMulRegular (α →₀ M) k 
Arguments: {α : Type u_1} {M : Type u_5} {R : Type u_11} [Zero M] [SMulZeroClass R M] {k : R} (hk : IsSMulRegular M k)
Goal: IsSMulRegular (α →₀ M) k
-- Finsupp.support_smul
theorem support_smul [AddMonoid M] [SMulZeroClass R M] {b : R} {g : α →₀ M} :
    (b • g).support ⊆ g.support 
Arguments: {α : Type u_1} {M : Type u_5} {R : Type u_11} [AddMonoid M] [SMulZeroClass R M] {b : R} {g : α →₀ M}
Goal: (b • g).support ⊆ g.support
-- Finsupp.support_smul_eq
@[simp]
theorem support_smul_eq [Semiring R] [AddCommMonoid M] [Module R M] [NoZeroSMulDivisors R M] {b : R}
    (hb : b ≠ 0) {g : α →₀ M} : (b • g).support = g.support 
Arguments: {α : Type u_1} {M : Type u_5} {R : Type u_11} [Semiring R] [AddCommMonoid M] [Module R M] [NoZeroSMulDivisors R M] {b : R} (hb : b ≠ 0) {g : α →₀ M}
Goal: (b • g).support = g.support
-- Finsupp.filter_smul
@[simp]
theorem filter_smul {_ : Monoid R} [AddMonoid M] [DistribMulAction R M] {b : R} {v : α →₀ M} :
    (b • v).filter p = b • v.filter p 
Arguments: {α : Type u_1} {M : Type u_5} {R : Type u_11} {p : α → Prop} [DecidablePred p]
Goal: ∀ {x : Monoid R} [inst : AddMonoid M] [inst_1 : DistribMulAction R M] {b : R} {v : α →₀ M},
  Finsupp.filter p (b • v) = b • Finsupp.filter p v
-- Finsupp.mapDomain_smul
theorem mapDomain_smul {_ : Monoid R} [AddCommMonoid M] [DistribMulAction R M] {f : α → β} (b : R)
    (v : α →₀ M) : mapDomain f (b • v) = b • mapDomain f v 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {R : Type u_11}
Goal: ∀ {x : Monoid R} [inst : AddCommMonoid M] [inst_1 : DistribMulAction R M] {f : α → β} (b : R) (v : α →₀ M),
  Finsupp.mapDomain f (b • v) = b • Finsupp.mapDomain f v
-- Finsupp.smul_single
@[simp]
theorem smul_single [Zero M] [SMulZeroClass R M] (c : R) (a : α) (b : M) :
    c • Finsupp.single a b = Finsupp.single a (c • b) 
Arguments: {α : Type u_1} {M : Type u_5} {R : Type u_11} [Zero M] [SMulZeroClass R M] (c : R) (a : α) (b : M)
Goal: c • Finsupp.single a b = Finsupp.single a (c • b)
-- Finsupp.smul_single'
theorem smul_single' {_ : Semiring R} (c : R) (a : α) (b : R) :
    c • Finsupp.single a b = Finsupp.single a (c * b) 
Arguments: {α : Type u_1} {R : Type u_11}
Goal: ∀ {x : Semiring R} (c : R) (a : α) (b : R), c • Finsupp.single a b = Finsupp.single a (c * b)
-- Finsupp.mapRange_smul
theorem mapRange_smul {_ : Monoid R} [AddMonoid M] [DistribMulAction R M] [AddMonoid N]
    [DistribMulAction R N] {f : M → N} {hf : f 0 = 0} (c : R) (v : α →₀ M)
    (hsmul : ∀ x, f (c • x) = c • f x) : mapRange f hf (c • v) = c • mapRange f hf v 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} {R : Type u_11}
Goal: ∀ {x : Monoid R} [inst : AddMonoid M] [inst_1 : DistribMulAction R M] [inst_2 : AddMonoid N]
  [inst_3 : DistribMulAction R N] {f : M → N} {hf : f 0 = 0} (c : R) (v : α →₀ M),
  (∀ (x_1 : M), f (c • x_1) = c • f x_1) → Finsupp.mapRange f hf (c • v) = c • Finsupp.mapRange f hf v
-- Finsupp.smul_single_one
theorem smul_single_one [Semiring R] (a : α) (b : R) : b • single a (1 : R) = single a b 
Arguments: {α : Type u_1} {R : Type u_11} [Semiring R] (a : α) (b : R)
Goal: b • Finsupp.single a 1 = Finsupp.single a b
-- Finsupp.comapDomain_smul
theorem comapDomain_smul [AddMonoid M] [Monoid R] [DistribMulAction R M] {f : α → β} (r : R)
    (v : β →₀ M) (hfv : Set.InjOn f (f ⁻¹' ↑v.support))
    (hfrv : Set.InjOn f (f ⁻¹' ↑(r • v).support) :=
      hfv.mono <| Set.preimage_mono <| Finset.coe_subset.mpr support_smul) :
    comapDomain f (r • v) hfrv = r • comapDomain f v hfv 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {R : Type u_11} [AddMonoid M] [Monoid R] [DistribMulAction R M] {f : α → β} (r : R) (v : β →₀ M) (hfv : Set.InjOn f (f ⁻¹' ↑v.support)) (hfrv : Set.InjOn f (f ⁻¹' ↑(r • v).support) := ⋯)
Goal: Finsupp.comapDomain f (r • v) hfrv = r • Finsupp.comapDomain f v hfv
-- Finsupp.comapDomain_smul_of_injective
theorem comapDomain_smul_of_injective [AddMonoid M] [Monoid R] [DistribMulAction R M] {f : α → β}
    (hf : Function.Injective f) (r : R) (v : β →₀ M) :
    comapDomain f (r • v) hf.injOn = r • comapDomain f v hf.injOn 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {R : Type u_11} [AddMonoid M] [Monoid R] [DistribMulAction R M] {f : α → β} (hf : Function.Injective f) (r : R) (v : β →₀ M)
Goal: Finsupp.comapDomain f (r • v) ⋯ = r • Finsupp.comapDomain f v ⋯
-- Finsupp.sum_smul_index
theorem sum_smul_index [Semiring R] [AddCommMonoid M] {g : α →₀ R} {b : R} {h : α → R → M}
    (h0 : ∀ i, h i 0 = 0) : (b • g).sum h = g.sum fun i a => h i (b * a) 
Arguments: {α : Type u_1} {M : Type u_5} {R : Type u_11} [Semiring R] [AddCommMonoid M] {g : α →₀ R} {b : R} {h : α → R → M} (h0 : ∀ (i : α), h i 0 = 0)
Goal: (b • g).sum h = g.sum fun i a => h i (b * a)
-- Finsupp.sum_smul_index'
theorem sum_smul_index' [AddMonoid M] [DistribSMul R M] [AddCommMonoid N] {g : α →₀ M} {b : R}
    {h : α → M → N} (h0 : ∀ i, h i 0 = 0) : (b • g).sum h = g.sum fun i c => h i (b • c) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} {R : Type u_11} [AddMonoid M] [DistribSMul R M] [AddCommMonoid N] {g : α →₀ M} {b : R} {h : α → M → N} (h0 : ∀ (i : α), h i 0 = 0)
Goal: (b • g).sum h = g.sum fun i c => h i (b • c)
-- Finsupp.sum_smul_index_addMonoidHom
theorem sum_smul_index_addMonoidHom [AddMonoid M] [AddCommMonoid N] [DistribSMul R M] {g : α →₀ M}
    {b : R} {h : α → M →+ N} : ((b • g).sum fun a => h a) = g.sum fun i c => h i (b • c) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} {R : Type u_11} [AddMonoid M] [AddCommMonoid N] [DistribSMul R M] {g : α →₀ M} {b : R} {h : α → M →+ N}
Goal: ((b • g).sum fun a => ⇑(h a)) = g.sum fun i c => (h i) (b • c)
-- Finsupp.distribMulActionHom_ext
theorem distribMulActionHom_ext {f g : (α →₀ M) →+[R] N}
    (h : ∀ (a : α) (m : M), f (single a m) = g (single a m)) : f = g 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} {R : Type u_11} [Semiring R] [AddCommMonoid M] [AddCommMonoid N] [DistribMulAction R M] [DistribMulAction R N] {f g : (α →₀ M) →+[R] N} (h : ∀ (a : α) (m : M), f (Finsupp.single a m) = g (Finsupp.single a m))
Goal: f = g
-- Finsupp.distribMulActionHom_ext'
@[ext]
theorem distribMulActionHom_ext' {f g : (α →₀ M) →+[R] N}
    (h : ∀ a : α, f.comp (DistribMulActionHom.single a) = g.comp (DistribMulActionHom.single a)) :
    f = g 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} {R : Type u_11} [Semiring R] [AddCommMonoid M] [AddCommMonoid N] [DistribMulAction R M] [DistribMulAction R N] {f g : (α →₀ M) →+[R] N} (h : ∀ (a : α), f.comp (Finsupp.DistribMulActionHom.single a) = g.comp (Finsupp.DistribMulActionHom.single a))
Goal: f = g
-- Finsupp.piecewise_support
@[simps]
def piecewise (f : Subtype P →₀ M) (g : {a // ¬ P a} →₀ M) : α →₀ M 
Arguments: {α : Type u_1} {M : Type u_13} [Zero M] {P : α → Prop} [DecidablePred P] (f : Subtype P →₀ M) (g : { a // ¬P a } →₀ M)
Goal: (f.piecewise g).support =
  (Finset.map (Function.Embedding.subtype P) f.support).disjUnion
    (Finset.map (Function.Embedding.subtype fun a => ¬P a) g.support) ⋯
-- Finsupp.piecewise_toFun
@[simps]
def piecewise (f : Subtype P →₀ M) (g : {a // ¬ P a} →₀ M) : α →₀ M 
Arguments: {α : Type u_1} {M : Type u_13} [Zero M] {P : α → Prop} [DecidablePred P] (f : Subtype P →₀ M) (g : { a // ¬P a } →₀ M) (a : α)
Goal: (f.piecewise g) a = if h : P a then f ⟨a, h⟩ else g ⟨a, h⟩
-- Finsupp.subtypeDomain_piecewise
@[simp]
theorem subtypeDomain_piecewise (f : Subtype P →₀ M) (g : {a // ¬ P a} →₀ M) :
    subtypeDomain P (f.piecewise g) = f 
Arguments: {α : Type u_1} {M : Type u_13} [Zero M] {P : α → Prop} [DecidablePred P] (f : Subtype P →₀ M) (g : { a // ¬P a } →₀ M)
Goal: Finsupp.subtypeDomain P (f.piecewise g) = f