ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finsupp.mapDomain_notin_range
theorem mapDomain_notin_range {f : α → β} (x : α →₀ M) (a : β) (h : a ∉ Set.range f) :
    mapDomain f x a = 0 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] {f : α → β} (x : α →₀ M) (a : β) (h : a ∉ Set.range f)
Goal: (Finsupp.mapDomain f x) a = 0
-- Finsupp.mapDomain_id
@[simp]
theorem mapDomain_id : mapDomain id v = v 
Arguments: {α : Type u_1} {M : Type u_5} [AddCommMonoid M] {v : α →₀ M}
Goal: Finsupp.mapDomain id v = v
-- Finsupp.mapDomain_comp
theorem mapDomain_comp {f : α → β} {g : β → γ} :
    mapDomain (g ∘ f) v = mapDomain g (mapDomain f v) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {M : Type u_5} [AddCommMonoid M] {v : α →₀ M} {f : α → β} {g : β → γ}
Goal: Finsupp.mapDomain (g ∘ f) v = Finsupp.mapDomain g (Finsupp.mapDomain f v)
-- Finsupp.mapDomain_single
@[simp]
theorem mapDomain_single {f : α → β} {a : α} {b : M} : mapDomain f (single a b) = single (f a) b 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] {f : α → β} {a : α} {b : M}
Goal: Finsupp.mapDomain f (Finsupp.single a b) = Finsupp.single (f a) b
-- Finsupp.mapDomain_zero
@[simp]
theorem mapDomain_zero {f : α → β} : mapDomain f (0 : α →₀ M) = (0 : β →₀ M) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] {f : α → β}
Goal: Finsupp.mapDomain f 0 = 0
-- Finsupp.mapDomain_congr
theorem mapDomain_congr {f g : α → β} (h : ∀ x ∈ v.support, f x = g x) :
    v.mapDomain f = v.mapDomain g 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] {v : α →₀ M} {f g : α → β} (h : ∀ x ∈ v.support, f x = g x)
Goal: Finsupp.mapDomain f v = Finsupp.mapDomain g v
-- Finsupp.mapDomain_add
theorem mapDomain_add {f : α → β} : mapDomain f (v₁ + v₂) = mapDomain f v₁ + mapDomain f v₂ 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] {v₁ v₂ : α →₀ M} {f : α → β}
Goal: Finsupp.mapDomain f (v₁ + v₂) = Finsupp.mapDomain f v₁ + Finsupp.mapDomain f v₂
-- Finsupp.mapDomain_equiv_apply
@[simp]
theorem mapDomain_equiv_apply {f : α ≃ β} (x : α →₀ M) (a : β) :
    mapDomain f x a = x (f.symm a) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] {f : α ≃ β} (x : α →₀ M) (a : β)
Goal: (Finsupp.mapDomain (⇑f) x) a = x (f.symm a)
-- Finsupp.mapDomain.addMonoidHom_apply
@[simps]
def mapDomain.addMonoidHom (f : α → β) : (α →₀ M) →+ β →₀ M 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] (f : α → β) (v : α →₀ M)
Goal: (Finsupp.mapDomain.addMonoidHom f) v = Finsupp.mapDomain f v
-- Finsupp.mapDomain.addMonoidHom_id
@[simp]
theorem mapDomain.addMonoidHom_id : mapDomain.addMonoidHom id = AddMonoidHom.id (α →₀ M) 
Arguments: {α : Type u_1} {M : Type u_5} [AddCommMonoid M]
Goal: Finsupp.mapDomain.addMonoidHom id = AddMonoidHom.id (α →₀ M)
-- Finsupp.mapDomain.addMonoidHom_comp
theorem mapDomain.addMonoidHom_comp (f : β → γ) (g : α → β) :
    (mapDomain.addMonoidHom (f ∘ g) : (α →₀ M) →+ γ →₀ M) =
      (mapDomain.addMonoidHom f).comp (mapDomain.addMonoidHom g) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {M : Type u_5} [AddCommMonoid M] (f : β → γ) (g : α → β)
Goal: Finsupp.mapDomain.addMonoidHom (f ∘ g) = (Finsupp.mapDomain.addMonoidHom f).comp (Finsupp.mapDomain.addMonoidHom g)
-- Finsupp.mapDomain_finset_sum
theorem mapDomain_finset_sum {f : α → β} {s : Finset ι} {v : ι → α →₀ M} :
    mapDomain f (∑ i ∈ s, v i) = ∑ i ∈ s, mapDomain f (v i) 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Type u_4} {M : Type u_5} [AddCommMonoid M] {f : α → β} {s : Finset ι} {v : ι → α →₀ M}
Goal: Finsupp.mapDomain f (∑ i ∈ s, v i) = ∑ i ∈ s, Finsupp.mapDomain f (v i)
-- Finsupp.mapDomain_sum
theorem mapDomain_sum [Zero N] {f : α → β} {s : α →₀ N} {v : α → N → α →₀ M} :
    mapDomain f (s.sum v) = s.sum fun a b => mapDomain f (v a b) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [Zero N] {f : α → β} {s : α →₀ N} {v : α → N → α →₀ M}
Goal: Finsupp.mapDomain f (s.sum v) = s.sum fun a b => Finsupp.mapDomain f (v a b)
-- Finsupp.mapDomain_support
theorem mapDomain_support [DecidableEq β] {f : α → β} {s : α →₀ M} :
    (s.mapDomain f).support ⊆ s.support.image f 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] [DecidableEq β] {f : α → β} {s : α →₀ M}
Goal: (Finsupp.mapDomain f s).support ⊆ Finset.image f s.support
-- Finsupp.mapDomain_apply'
theorem mapDomain_apply' (S : Set α) {f : α → β} (x : α →₀ M) (hS : (x.support : Set α) ⊆ S)
    (hf : Set.InjOn f S) {a : α} (ha : a ∈ S) : mapDomain f x (f a) = x a 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] (S : Set α) {f : α → β} (x : α →₀ M) (hS : ↑x.support ⊆ S) (hf : Set.InjOn f S) {a : α} (ha : a ∈ S)
Goal: (Finsupp.mapDomain f x) (f a) = x a
-- Finsupp.mapDomain_support_of_injOn
theorem mapDomain_support_of_injOn [DecidableEq β] {f : α → β} (s : α →₀ M)
    (hf : Set.InjOn f s.support) : (mapDomain f s).support = Finset.image f s.support 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] [DecidableEq β] {f : α → β} (s : α →₀ M) (hf : Set.InjOn f ↑s.support)
Goal: (Finsupp.mapDomain f s).support = Finset.image f s.support
-- Finsupp.mapDomain_support_of_injective
theorem mapDomain_support_of_injective [DecidableEq β] {f : α → β} (hf : Function.Injective f)
    (s : α →₀ M) : (mapDomain f s).support = Finset.image f s.support 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] [DecidableEq β] {f : α → β} (hf : Function.Injective f) (s : α →₀ M)
Goal: (Finsupp.mapDomain f s).support = Finset.image f s.support
-- Finsupp.sum_mapDomain_index
@[to_additive]
theorem prod_mapDomain_index [CommMonoid N] {f : α → β} {s : α →₀ M} {h : β → M → N}
    (h_zero : ∀ b, h b 0 = 1) (h_add : ∀ b m₁ m₂, h b (m₁ + m₂) = h b m₁ * h b m₂) :
    (mapDomain f s).prod h = s.prod fun a m => h (f a) m 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [AddCommMonoid N] {f : α → β} {s : α →₀ M} {h : β → M → N} (h_zero : ∀ (b : β), h b 0 = 0) (h_add : ∀ (b : β) (m₁ m₂ : M), h b (m₁ + m₂) = h b m₁ + h b m₂)
Goal: (Finsupp.mapDomain f s).sum h = s.sum fun a m => h (f a) m
-- Finsupp.prod_mapDomain_index
@[to_additive]
theorem prod_mapDomain_index [CommMonoid N] {f : α → β} {s : α →₀ M} {h : β → M → N}
    (h_zero : ∀ b, h b 0 = 1) (h_add : ∀ b m₁ m₂, h b (m₁ + m₂) = h b m₁ * h b m₂) :
    (mapDomain f s).prod h = s.prod fun a m => h (f a) m 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [CommMonoid N] {f : α → β} {s : α →₀ M} {h : β → M → N} (h_zero : ∀ (b : β), h b 0 = 1) (h_add : ∀ (b : β) (m₁ m₂ : M), h b (m₁ + m₂) = h b m₁ * h b m₂)
Goal: (Finsupp.mapDomain f s).prod h = s.prod fun a m => h (f a) m
-- Finsupp.sum_mapDomain_index_addMonoidHom
@[simp]
theorem sum_mapDomain_index_addMonoidHom [AddCommMonoid N] {f : α → β} {s : α →₀ M}
    (h : β → M →+ N) : ((mapDomain f s).sum fun b m => h b m) = s.sum fun a m => h (f a) m 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [AddCommMonoid N] {f : α → β} {s : α →₀ M} (h : β → M →+ N)
Goal: ((Finsupp.mapDomain f s).sum fun b m => (h b) m) = s.sum fun a m => (h (f a)) m
-- Finsupp.embDomain_eq_mapDomain
theorem embDomain_eq_mapDomain (f : α ↪ β) (v : α →₀ M) : embDomain f v = mapDomain f v 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] (f : α ↪ β) (v : α →₀ M)
Goal: Finsupp.embDomain f v = Finsupp.mapDomain (⇑f) v
-- Finsupp.prod_mapDomain_index_inj
@[to_additive]
theorem prod_mapDomain_index_inj [CommMonoid N] {f : α → β} {s : α →₀ M} {h : β → M → N}
    (hf : Function.Injective f) : (s.mapDomain f).prod h = s.prod fun a b => h (f a) b 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [CommMonoid N] {f : α → β} {s : α →₀ M} {h : β → M → N} (hf : Function.Injective f)
Goal: (Finsupp.mapDomain f s).prod h = s.prod fun a b => h (f a) b
-- Finsupp.sum_mapDomain_index_inj
@[to_additive]
theorem prod_mapDomain_index_inj [CommMonoid N] {f : α → β} {s : α →₀ M} {h : β → M → N}
    (hf : Function.Injective f) : (s.mapDomain f).prod h = s.prod fun a b => h (f a) b 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [AddCommMonoid N] {f : α → β} {s : α →₀ M} {h : β → M → N} (hf : Function.Injective f)
Goal: (Finsupp.mapDomain f s).sum h = s.sum fun a b => h (f a) b
-- Finsupp.mapDomain_injective
theorem mapDomain_injective {f : α → β} (hf : Function.Injective f) :
    Function.Injective (mapDomain f : (α →₀ M) → β →₀ M) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] {f : α → β} (hf : Function.Injective f)
Goal: Function.Injective (Finsupp.mapDomain f)
-- Finsupp.mapDomainEmbedding_apply
@[simps]
def mapDomainEmbedding {α β : Type*} (f : α ↪ β) : (α →₀ ℕ) ↪ β →₀ ℕ 
Arguments: {α : Type u_13} {β : Type u_14} (f : α ↪ β) (v : α →₀ ℕ)
Goal: (Finsupp.mapDomainEmbedding f) v = Finsupp.mapDomain (⇑f) v
-- Finsupp.mapDomain.addMonoidHom_comp_mapRange
theorem mapDomain.addMonoidHom_comp_mapRange [AddCommMonoid N] (f : α → β) (g : M →+ N) :
    (mapDomain.addMonoidHom f).comp (mapRange.addMonoidHom g) =
      (mapRange.addMonoidHom g).comp (mapDomain.addMonoidHom f) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [AddCommMonoid N] (f : α → β) (g : M →+ N)
Goal: (Finsupp.mapDomain.addMonoidHom f).comp (Finsupp.mapRange.addMonoidHom g) =
  (Finsupp.mapRange.addMonoidHom g).comp (Finsupp.mapDomain.addMonoidHom f)
-- Finsupp.mapDomain_mapRange
theorem mapDomain_mapRange [AddCommMonoid N] (f : α → β) (v : α →₀ M) (g : M → N) (h0 : g 0 = 0)
    (hadd : ∀ x y, g (x + y) = g x + g y) :
    mapDomain f (mapRange g h0 v) = mapRange g h0 (mapDomain f v) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [AddCommMonoid N] (f : α → β) (v : α →₀ M) (g : M → N) (h0 : g 0 = 0) (hadd : ∀ (x y : M), g (x + y) = g x + g y)
Goal: Finsupp.mapDomain f (Finsupp.mapRange g h0 v) = Finsupp.mapRange g h0 (Finsupp.mapDomain f v)
-- Finsupp.sum_update_add
theorem sum_update_add [AddCommMonoid α] [AddCommMonoid β] (f : ι →₀ α) (i : ι) (a : α)
    (g : ι → α → β) (hg : ∀ i, g i 0 = 0)
    (hgg : ∀ (j : ι) (a₁ a₂ : α), g j (a₁ + a₂) = g j a₁ + g j a₂) :
    (f.update i a).sum g + g i (f i) = f.sum g + g i a 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Type u_4} [AddCommMonoid α] [AddCommMonoid β] (f : ι →₀ α) (i : ι) (a : α) (g : ι → α → β) (hg : ∀ (i : ι), g i 0 = 0) (hgg : ∀ (j : ι) (a₁ a₂ : α), g j (a₁ + a₂) = g j a₁ + g j a₂)
Goal: (f.update i a).sum g + g i (f i) = f.sum g + g i a
-- Finsupp.mapDomain_injOn
theorem mapDomain_injOn (S : Set α) {f : α → β} (hf : Set.InjOn f S) :
    Set.InjOn (mapDomain f : (α →₀ M) → β →₀ M) { w | (w.support : Set α) ⊆ S } 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] (S : Set α) {f : α → β} (hf : Set.InjOn f S)
Goal: Set.InjOn (Finsupp.mapDomain f) {w | ↑w.support ⊆ S}
-- Finsupp.equivMapDomain_eq_mapDomain
theorem equivMapDomain_eq_mapDomain {M} [AddCommMonoid M] (f : α ≃ β) (l : α →₀ M) :
    equivMapDomain f l = mapDomain f l 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_13} [AddCommMonoid M] (f : α ≃ β) (l : α →₀ M)
Goal: Finsupp.equivMapDomain f l = Finsupp.mapDomain (⇑f) l
-- Finsupp.comapDomain_support
@[simps support]
def comapDomain [Zero M] (f : α → β) (l : β →₀ M) (hf : Set.InjOn f (f ⁻¹' ↑l.support)) :
    α →₀ M 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α → β) (l : β →₀ M) (hf : Set.InjOn f (f ⁻¹' ↑l.support))
Goal: (Finsupp.comapDomain f l hf).support = l.support.preimage f hf
-- Finsupp.comapDomain_apply
@[simp]
theorem comapDomain_apply [Zero M] (f : α → β) (l : β →₀ M) (hf : Set.InjOn f (f ⁻¹' ↑l.support))
    (a : α) : comapDomain f l hf a = l (f a) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α → β) (l : β →₀ M) (hf : Set.InjOn f (f ⁻¹' ↑l.support)) (a : α)
Goal: (Finsupp.comapDomain f l hf) a = l (f a)
-- Finsupp.sum_comapDomain
theorem sum_comapDomain [Zero M] [AddCommMonoid N] (f : α → β) (l : β →₀ M) (g : β → M → N)
    (hf : Set.BijOn f (f ⁻¹' ↑l.support) ↑l.support) :
    (comapDomain f l hf.injOn).sum (g ∘ f) = l.sum g 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_7} [Zero M] [AddCommMonoid N] (f : α → β) (l : β →₀ M) (g : β → M → N) (hf : Set.BijOn f (f ⁻¹' ↑l.support) ↑l.support)
Goal: (Finsupp.comapDomain f l ⋯).sum (g ∘ f) = l.sum g
-- Finsupp.eq_zero_of_comapDomain_eq_zero
theorem eq_zero_of_comapDomain_eq_zero [AddCommMonoid M] (f : α → β) (l : β →₀ M)
    (hf : Set.BijOn f (f ⁻¹' ↑l.support) ↑l.support) : comapDomain f l hf.injOn = 0 → l = 0 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] (f : α → β) (l : β →₀ M) (hf : Set.BijOn f (f ⁻¹' ↑l.support) ↑l.support)
Goal: Finsupp.comapDomain f l ⋯ = 0 → l = 0
-- Finsupp.embDomain_comapDomain
lemma embDomain_comapDomain {f : α ↪ β} {g : β →₀ M} (hg : ↑g.support ⊆ Set.range f) :
    embDomain f (comapDomain f g f.injective.injOn) = g 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] {f : α ↪ β} {g : β →₀ M} (hg : ↑g.support ⊆ Set.range ⇑f)
Goal: Finsupp.embDomain f (Finsupp.comapDomain (⇑f) g ⋯) = g
-- Finsupp.comapDomain_zero
@[simp]
theorem comapDomain_zero (f : α → β)
    (hif : Set.InjOn f (f ⁻¹' ↑(0 : β →₀ M).support) := Finset.coe_empty ▸ (Set.injOn_empty f)) :
    comapDomain f (0 : β →₀ M) hif = (0 : α →₀ M) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α → β) (hif : Set.InjOn f (f ⁻¹' ↑(Finsupp.support 0)) := ⋯)
Goal: Finsupp.comapDomain f 0 hif = 0
-- Finsupp.comapDomain_single
@[simp]
theorem comapDomain_single (f : α → β) (a : α) (m : M)
    (hif : Set.InjOn f (f ⁻¹' (single (f a) m).support)) :
    comapDomain f (Finsupp.single (f a) m) hif = Finsupp.single a m 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α → β) (a : α) (m : M) (hif : Set.InjOn f (f ⁻¹' ↑(Finsupp.single (f a) m).support))
Goal: Finsupp.comapDomain f (Finsupp.single (f a) m) hif = Finsupp.single a m
-- Finsupp.comapDomain_add
theorem comapDomain_add (v₁ v₂ : β →₀ M) (hv₁ : Set.InjOn f (f ⁻¹' ↑v₁.support))
    (hv₂ : Set.InjOn f (f ⁻¹' ↑v₂.support)) (hv₁₂ : Set.InjOn f (f ⁻¹' ↑(v₁ + v₂).support)) :
    comapDomain f (v₁ + v₂) hv₁₂ = comapDomain f v₁ hv₁ + comapDomain f v₂ hv₂ 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddZeroClass M] {f : α → β} (v₁ v₂ : β →₀ M) (hv₁ : Set.InjOn f (f ⁻¹' ↑v₁.support)) (hv₂ : Set.InjOn f (f ⁻¹' ↑v₂.support)) (hv₁₂ : Set.InjOn f (f ⁻¹' ↑(v₁ + v₂).support))
Goal: Finsupp.comapDomain f (v₁ + v₂) hv₁₂ = Finsupp.comapDomain f v₁ hv₁ + Finsupp.comapDomain f v₂ hv₂
-- Finsupp.comapDomain_add_of_injective
theorem comapDomain_add_of_injective (hf : Function.Injective f) (v₁ v₂ : β →₀ M) :
    comapDomain f (v₁ + v₂) hf.injOn =
      comapDomain f v₁ hf.injOn + comapDomain f v₂ hf.injOn 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddZeroClass M] {f : α → β} (hf : Function.Injective f) (v₁ v₂ : β →₀ M)
Goal: Finsupp.comapDomain f (v₁ + v₂) ⋯ = Finsupp.comapDomain f v₁ ⋯ + Finsupp.comapDomain f v₂ ⋯
-- Finsupp.comapDomain.addMonoidHom_apply
@[simps]
def comapDomain.addMonoidHom (hf : Function.Injective f) : (β →₀ M) →+ α →₀ M 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddZeroClass M] {f : α → β} (hf : Function.Injective f) (x : β →₀ M)
Goal: (Finsupp.comapDomain.addMonoidHom hf) x = Finsupp.comapDomain f x ⋯
-- Finsupp.mapDomain_comapDomain
theorem mapDomain_comapDomain (hf : Function.Injective f) (l : β →₀ M)
    (hl : ↑l.support ⊆ Set.range f) :
    mapDomain f (comapDomain f l hf.injOn) = l 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] (f : α → β) (hf : Function.Injective f) (l : β →₀ M) (hl : ↑l.support ⊆ Set.range f)
Goal: Finsupp.mapDomain f (Finsupp.comapDomain f l ⋯) = l
-- Finsupp.some_apply
@[simp]
theorem some_apply [Zero M] (f : Option α →₀ M) (a : α) : f.some a = f (Option.some a) 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (f : Option α →₀ M) (a : α)
Goal: f.some a = f (some a)
-- Finsupp.some_zero
@[simp]
theorem some_zero [Zero M] : (0 : Option α →₀ M).some = 0 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M]
Goal: Finsupp.some 0 = 0
-- Finsupp.some_add
@[simp]
theorem some_add [AddCommMonoid M] (f g : Option α →₀ M) : (f + g).some = f.some + g.some 
Arguments: {α : Type u_1} {M : Type u_5} [AddCommMonoid M] (f g : Option α →₀ M)
Goal: (f + g).some = f.some + g.some
-- Finsupp.some_single_none
@[simp]
theorem some_single_none [Zero M] (m : M) : (single none m : Option α →₀ M).some = 0 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (m : M)
Goal: (Finsupp.single none m).some = 0
-- Finsupp.some_single_some
@[simp]
theorem some_single_some [Zero M] (a : α) (m : M) :
    (single (Option.some a) m : Option α →₀ M).some = single a m 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (a : α) (m : M)
Goal: (Finsupp.single (some a) m).some = Finsupp.single a m
-- Finsupp.sum_option_index
@[to_additive]
theorem prod_option_index [AddCommMonoid M] [CommMonoid N] (f : Option α →₀ M)
    (b : Option α → M → N) (h_zero : ∀ o, b o 0 = 1)
    (h_add : ∀ o m₁ m₂, b o (m₁ + m₂) = b o m₁ * b o m₂) :
    f.prod b = b none (f none) * f.some.prod fun a => b (Option.some a) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [AddCommMonoid N] (f : Option α →₀ M) (b : Option α → M → N) (h_zero : ∀ (o : Option α), b o 0 = 0) (h_add : ∀ (o : Option α) (m₁ m₂ : M), b o (m₁ + m₂) = b o m₁ + b o m₂)
Goal: f.sum b = b none (f none) + f.some.sum fun a => b (some a)
-- Finsupp.prod_option_index
@[to_additive]
theorem prod_option_index [AddCommMonoid M] [CommMonoid N] (f : Option α →₀ M)
    (b : Option α → M → N) (h_zero : ∀ o, b o 0 = 1)
    (h_add : ∀ o m₁ m₂, b o (m₁ + m₂) = b o m₁ * b o m₂) :
    f.prod b = b none (f none) * f.some.prod fun a => b (Option.some a) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [CommMonoid N] (f : Option α →₀ M) (b : Option α → M → N) (h_zero : ∀ (o : Option α), b o 0 = 1) (h_add : ∀ (o : Option α) (m₁ m₂ : M), b o (m₁ + m₂) = b o m₁ * b o m₂)
Goal: f.prod b = b none (f none) * f.some.prod fun a => b (some a)
-- Finsupp.sum_option_index_smul
theorem sum_option_index_smul [Semiring R] [AddCommMonoid M] [Module R M] (f : Option α →₀ R)
    (b : Option α → M) :
    (f.sum fun o r => r • b o) = f none • b none + f.some.sum fun a r => r • b (Option.some a) 
Arguments: {α : Type u_1} {M : Type u_5} {R : Type u_11} [Semiring R] [AddCommMonoid M] [Module R M] (f : Option α →₀ R) (b : Option α → M)
Goal: (f.sum fun o r => r • b o) = f none • b none + f.some.sum fun a r => r • b (some a)
-- Finsupp.filter_apply
theorem filter_apply (a : α) : f.filter p a = if p a then f a else 0 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (p : α → Prop) [DecidablePred p] (f : α →₀ M) (a : α)
Goal: (Finsupp.filter p f) a = if p a then f a else 0
-- Finsupp.filter_eq_indicator
theorem filter_eq_indicator : ⇑(f.filter p) = Set.indicator { x | p x } f 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (p : α → Prop) [DecidablePred p] (f : α →₀ M)
Goal: ⇑(Finsupp.filter p f) = {x | p x}.indicator ⇑f
-- Finsupp.filter_eq_zero_iff
theorem filter_eq_zero_iff : f.filter p = 0 ↔ ∀ x, p x → f x = 0 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (p : α → Prop) [DecidablePred p] (f : α →₀ M)
Goal: Finsupp.filter p f = 0 ↔ ∀ (x : α), p x → f x = 0
-- Finsupp.filter_eq_self_iff
theorem filter_eq_self_iff : f.filter p = f ↔ ∀ x, f x ≠ 0 → p x 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (p : α → Prop) [DecidablePred p] (f : α →₀ M)
Goal: Finsupp.filter p f = f ↔ ∀ (x : α), f x ≠ 0 → p x
-- Finsupp.filter_apply_pos
@[simp]
theorem filter_apply_pos {a : α} (h : p a) : f.filter p a = f a 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (p : α → Prop) [DecidablePred p] (f : α →₀ M) {a : α} (h : p a)
Goal: (Finsupp.filter p f) a = f a
-- Finsupp.filter_apply_neg
@[simp]
theorem filter_apply_neg {a : α} (h : ¬p a) : f.filter p a = 0 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (p : α → Prop) [DecidablePred p] (f : α →₀ M) {a : α} (h : ¬p a)
Goal: (Finsupp.filter p f) a = 0
-- Finsupp.support_filter
@[simp]
theorem support_filter : (f.filter p).support = f.support.filter p 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (p : α → Prop) [DecidablePred p] (f : α →₀ M)
Goal: (Finsupp.filter p f).support = Finset.filter p f.support
-- Finsupp.filter_zero
theorem filter_zero : (0 : α →₀ M).filter p = 0 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (p : α → Prop) [DecidablePred p]
Goal: Finsupp.filter p 0 = 0
-- Finsupp.filter_single_of_pos
@[simp]
theorem filter_single_of_pos {a : α} {b : M} (h : p a) : (single a b).filter p = single a b 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (p : α → Prop) [DecidablePred p] {a : α} {b : M} (h : p a)
Goal: Finsupp.filter p (Finsupp.single a b) = Finsupp.single a b
-- Finsupp.filter_single_of_neg
@[simp]
theorem filter_single_of_neg {a : α} {b : M} (h : ¬p a) : (single a b).filter p = 0 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (p : α → Prop) [DecidablePred p] {a : α} {b : M} (h : ¬p a)
Goal: Finsupp.filter p (Finsupp.single a b) = 0
-- Finsupp.prod_filter_index
@[to_additive]
theorem prod_filter_index [CommMonoid N] (g : α → M → N) :
    (f.filter p).prod g = ∏ x ∈ (f.filter p).support, g x (f x) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [Zero M] (p : α → Prop) [DecidablePred p] (f : α →₀ M) [CommMonoid N] (g : α → M → N)
Goal: (Finsupp.filter p f).prod g = ∏ x ∈ (Finsupp.filter p f).support, g x (f x)
-- Finsupp.sum_filter_index
@[to_additive]
theorem prod_filter_index [CommMonoid N] (g : α → M → N) :
    (f.filter p).prod g = ∏ x ∈ (f.filter p).support, g x (f x) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [Zero M] (p : α → Prop) [DecidablePred p] (f : α →₀ M) [AddCommMonoid N] (g : α → M → N)
Goal: (Finsupp.filter p f).sum g = ∑ x ∈ (Finsupp.filter p f).support, g x (f x)
-- Finsupp.sum_filter_add_sum_filter_not
@[to_additive (attr := simp)]
theorem prod_filter_mul_prod_filter_not [CommMonoid N] (g : α → M → N) :
    (f.filter p).prod g * (f.filter fun a => ¬p a).prod g = f.prod g 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [Zero M] (p : α → Prop) [DecidablePred p] (f : α →₀ M) [AddCommMonoid N] (g : α → M → N)
Goal: (Finsupp.filter p f).sum g + (Finsupp.filter (fun a => ¬p a) f).sum g = f.sum g
-- Finsupp.prod_filter_mul_prod_filter_not
@[to_additive (attr := simp)]
theorem prod_filter_mul_prod_filter_not [CommMonoid N] (g : α → M → N) :
    (f.filter p).prod g * (f.filter fun a => ¬p a).prod g = f.prod g 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [Zero M] (p : α → Prop) [DecidablePred p] (f : α →₀ M) [CommMonoid N] (g : α → M → N)
Goal: (Finsupp.filter p f).prod g * (Finsupp.filter (fun a => ¬p a) f).prod g = f.prod g
-- Finsupp.sum_sub_sum_filter
@[to_additive (attr := simp)]
theorem prod_div_prod_filter [CommGroup G] (g : α → M → G) :
    f.prod g / (f.filter p).prod g = (f.filter fun a => ¬p a).prod g 
Arguments: {α : Type u_1} {M : Type u_5} {G : Type u_9} [Zero M] (p : α → Prop) [DecidablePred p] (f : α →₀ M) [AddCommGroup G] (g : α → M → G)
Goal: f.sum g - (Finsupp.filter p f).sum g = (Finsupp.filter (fun a => ¬p a) f).sum g
-- Finsupp.prod_div_prod_filter
@[to_additive (attr := simp)]
theorem prod_div_prod_filter [CommGroup G] (g : α → M → G) :
    f.prod g / (f.filter p).prod g = (f.filter fun a => ¬p a).prod g 
Arguments: {α : Type u_1} {M : Type u_5} {G : Type u_9} [Zero M] (p : α → Prop) [DecidablePred p] (f : α →₀ M) [CommGroup G] (g : α → M → G)
Goal: f.prod g / (Finsupp.filter p f).prod g = (Finsupp.filter (fun a => ¬p a) f).prod g
-- Finsupp.filter_pos_add_filter_neg
theorem filter_pos_add_filter_neg [AddZeroClass M] (f : α →₀ M) (p : α → Prop) [DecidablePred p] :
    (f.filter p + f.filter fun a => ¬p a) = f 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] (f : α →₀ M) (p : α → Prop) [DecidablePred p]
Goal: Finsupp.filter p f + Finsupp.filter (fun a => ¬p a) f = f
-- Finsupp.mem_frange
theorem mem_frange {f : α →₀ M} {y : M} : y ∈ f.frange ↔ y ≠ 0 ∧ ∃ x, f x = y 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {f : α →₀ M} {y : M}
Goal: y ∈ f.frange ↔ y ≠ 0 ∧ ∃ x, f x = y