ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finsupp.erase_idem
theorem erase_idem (f : α →₀ M) (a : α) :
    erase a (erase a f) = erase a f 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (f : α →₀ M) (a : α)
Goal: Finsupp.erase a (Finsupp.erase a f) = Finsupp.erase a f
-- Finsupp.update_erase_eq_update
@[simp] theorem update_erase_eq_update (f : α →₀ M) (a : α) (b : M) :
    update (erase a f) a b = update f a b 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (f : α →₀ M) (a : α) (b : M)
Goal: (Finsupp.erase a f).update a b = f.update a b
-- Finsupp.erase_update_eq_erase
@[simp] theorem erase_update_eq_erase (f : α →₀ M) (a : α) (b : M) :
    erase a (update f a b) = erase a f 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (f : α →₀ M) (a : α) (b : M)
Goal: Finsupp.erase a (f.update a b) = Finsupp.erase a f
-- Finsupp.coe_onFinset
@[simp, norm_cast] lemma coe_onFinset (s : Finset α) (f : α → M) (hf) : onFinset s f hf = f 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (s : Finset α) (f : α → M) (hf : ∀ (a : α), f a ≠ 0 → a ∈ s)
Goal: ⇑(Finsupp.onFinset s f hf) = f
-- Finsupp.onFinset_apply
@[simp]
theorem onFinset_apply {s : Finset α} {f : α → M} {hf a} : (onFinset s f hf : α →₀ M) a = f a 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {s : Finset α} {f : α → M} {hf : ∀ (a : α), f a ≠ 0 → a ∈ s} {a : α}
Goal: (Finsupp.onFinset s f hf) a = f a
-- Finsupp.support_onFinset_subset
@[simp]
theorem support_onFinset_subset {s : Finset α} {f : α → M} {hf} :
    (onFinset s f hf).support ⊆ s 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {s : Finset α} {f : α → M} {hf : ∀ (a : α), f a ≠ 0 → a ∈ s}
Goal: (Finsupp.onFinset s f hf).support ⊆ s
-- Finsupp.mem_support_onFinset
theorem mem_support_onFinset {s : Finset α} {f : α → M} (hf : ∀ a : α, f a ≠ 0 → a ∈ s) {a : α} :
    a ∈ (Finsupp.onFinset s f hf).support ↔ f a ≠ 0 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {s : Finset α} {f : α → M} (hf : ∀ (a : α), f a ≠ 0 → a ∈ s) {a : α}
Goal: a ∈ (Finsupp.onFinset s f hf).support ↔ f a ≠ 0
-- Finsupp.support_onFinset
theorem support_onFinset [DecidableEq M] {s : Finset α} {f : α → M}
    (hf : ∀ a : α, f a ≠ 0 → a ∈ s) :
    (Finsupp.onFinset s f hf).support = s.filter fun a => f a ≠ 0 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] [DecidableEq M] {s : Finset α} {f : α → M} (hf : ∀ (a : α), f a ≠ 0 → a ∈ s)
Goal: (Finsupp.onFinset s f hf).support = Finset.filter (fun a => f a ≠ 0) s
-- Finsupp.ofSupportFinite_coe
theorem ofSupportFinite_coe {f : α → M} {hf : (Function.support f).Finite} :
    (ofSupportFinite f hf : α → M) = f 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {f : α → M} {hf : (Function.support f).Finite}
Goal: ⇑(Finsupp.ofSupportFinite f hf) = f
-- Finsupp.mapRange_apply
@[simp]
theorem mapRange_apply {f : M → N} {hf : f 0 = 0} {g : α →₀ M} {a : α} :
    mapRange f hf g a = f (g a) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [Zero M] [Zero N] {f : M → N} {hf : f 0 = 0} {g : α →₀ M} {a : α}
Goal: (Finsupp.mapRange f hf g) a = f (g a)
-- Finsupp.mapRange_zero
@[simp]
theorem mapRange_zero {f : M → N} {hf : f 0 = 0} : mapRange f hf (0 : α →₀ M) = 0 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [Zero M] [Zero N] {f : M → N} {hf : f 0 = 0}
Goal: Finsupp.mapRange f hf 0 = 0
-- Finsupp.mapRange_id
@[simp]
theorem mapRange_id (g : α →₀ M) : mapRange id rfl g = g 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (g : α →₀ M)
Goal: Finsupp.mapRange id ⋯ g = g
-- Finsupp.mapRange_comp
theorem mapRange_comp (f : N → P) (hf : f 0 = 0) (f₂ : M → N) (hf₂ : f₂ 0 = 0) (h : (f ∘ f₂) 0 = 0)
    (g : α →₀ M) : mapRange (f ∘ f₂) h g = mapRange f hf (mapRange f₂ hf₂ g) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} {P : Type u_8} [Zero M] [Zero N] [Zero P] (f : N → P) (hf : f 0 = 0) (f₂ : M → N) (hf₂ : f₂ 0 = 0) (h : (f ∘ f₂) 0 = 0) (g : α →₀ M)
Goal: Finsupp.mapRange (f ∘ f₂) h g = Finsupp.mapRange f hf (Finsupp.mapRange f₂ hf₂ g)
-- Finsupp.support_mapRange
theorem support_mapRange {f : M → N} {hf : f 0 = 0} {g : α →₀ M} :
    (mapRange f hf g).support ⊆ g.support 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [Zero M] [Zero N] {f : M → N} {hf : f 0 = 0} {g : α →₀ M}
Goal: (Finsupp.mapRange f hf g).support ⊆ g.support
-- Finsupp.mapRange_single
@[simp]
theorem mapRange_single {f : M → N} {hf : f 0 = 0} {a : α} {b : M} :
    mapRange f hf (single a b) = single a (f b) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [Zero M] [Zero N] {f : M → N} {hf : f 0 = 0} {a : α} {b : M}
Goal: Finsupp.mapRange f hf (Finsupp.single a b) = Finsupp.single a (f b)
-- Finsupp.support_mapRange_of_injective
theorem support_mapRange_of_injective {e : M → N} (he0 : e 0 = 0) (f : ι →₀ M)
    (he : Function.Injective e) : (Finsupp.mapRange e he0 f).support = f.support 
Arguments: {ι : Type u_4} {M : Type u_5} {N : Type u_7} [Zero M] [Zero N] {e : M → N} (he0 : e 0 = 0) (f : ι →₀ M) (he : Function.Injective e)
Goal: (Finsupp.mapRange e he0 f).support = f.support
-- Finsupp.support_embDomain
@[simp]
theorem support_embDomain (f : α ↪ β) (v : α →₀ M) : (embDomain f v).support = v.support.map f 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α ↪ β) (v : α →₀ M)
Goal: (Finsupp.embDomain f v).support = Finset.map f v.support
-- Finsupp.embDomain_zero
@[simp]
theorem embDomain_zero (f : α ↪ β) : (embDomain f 0 : β →₀ M) = 0 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α ↪ β)
Goal: Finsupp.embDomain f 0 = 0
-- Finsupp.embDomain_apply
@[simp]
theorem embDomain_apply (f : α ↪ β) (v : α →₀ M) (a : α) : embDomain f v (f a) = v a 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α ↪ β) (v : α →₀ M) (a : α)
Goal: (Finsupp.embDomain f v) (f a) = v a
-- Finsupp.embDomain_notin_range
theorem embDomain_notin_range (f : α ↪ β) (v : α →₀ M) (a : β) (h : a ∉ Set.range f) :
    embDomain f v a = 0 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α ↪ β) (v : α →₀ M) (a : β) (h : a ∉ Set.range ⇑f)
Goal: (Finsupp.embDomain f v) a = 0
-- Finsupp.embDomain_injective
theorem embDomain_injective (f : α ↪ β) : Function.Injective (embDomain f : (α →₀ M) → β →₀ M) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α ↪ β)
Goal: Function.Injective (Finsupp.embDomain f)
-- Finsupp.embDomain_inj
@[simp]
theorem embDomain_inj {f : α ↪ β} {l₁ l₂ : α →₀ M} : embDomain f l₁ = embDomain f l₂ ↔ l₁ = l₂ 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] {f : α ↪ β} {l₁ l₂ : α →₀ M}
Goal: Finsupp.embDomain f l₁ = Finsupp.embDomain f l₂ ↔ l₁ = l₂
-- Finsupp.embDomain_eq_zero
@[simp]
theorem embDomain_eq_zero {f : α ↪ β} {l : α →₀ M} : embDomain f l = 0 ↔ l = 0 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] {f : α ↪ β} {l : α →₀ M}
Goal: Finsupp.embDomain f l = 0 ↔ l = 0
-- Finsupp.embDomain_mapRange
theorem embDomain_mapRange (f : α ↪ β) (g : M → N) (p : α →₀ M) (hg : g 0 = 0) :
    embDomain f (mapRange g hg p) = mapRange g hg (embDomain f p) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_7} [Zero M] [Zero N] (f : α ↪ β) (g : M → N) (p : α →₀ M) (hg : g 0 = 0)
Goal: Finsupp.embDomain f (Finsupp.mapRange g hg p) = Finsupp.mapRange g hg (Finsupp.embDomain f p)
-- Finsupp.single_of_embDomain_single
theorem single_of_embDomain_single (l : α →₀ M) (f : α ↪ β) (a : β) (b : M) (hb : b ≠ 0)
    (h : l.embDomain f = single a b) : ∃ x, l = single x b ∧ f x = a 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (l : α →₀ M) (f : α ↪ β) (a : β) (b : M) (hb : b ≠ 0) (h : Finsupp.embDomain f l = Finsupp.single a b)
Goal: ∃ x, l = Finsupp.single x b ∧ f x = a
-- Finsupp.embDomain_single
@[simp]
theorem embDomain_single (f : α ↪ β) (a : α) (m : M) :
    embDomain f (single a m) = single (f a) m 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α ↪ β) (a : α) (m : M)
Goal: Finsupp.embDomain f (Finsupp.single a m) = Finsupp.single (f a) m
-- Finsupp.zipWith_apply
@[simp]
theorem zipWith_apply {f : M → N → P} {hf : f 0 0 = 0} {g₁ : α →₀ M} {g₂ : α →₀ N} {a : α} :
    zipWith f hf g₁ g₂ a = f (g₁ a) (g₂ a) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} {P : Type u_8} [Zero M] [Zero N] [Zero P] {f : M → N → P} {hf : f 0 0 = 0} {g₁ : α →₀ M} {g₂ : α →₀ N} {a : α}
Goal: (Finsupp.zipWith f hf g₁ g₂) a = f (g₁ a) (g₂ a)
-- Finsupp.support_zipWith
theorem support_zipWith [D : DecidableEq α] {f : M → N → P} {hf : f 0 0 = 0} {g₁ : α →₀ M}
    {g₂ : α →₀ N} : (zipWith f hf g₁ g₂).support ⊆ g₁.support ∪ g₂.support 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} {P : Type u_8} [Zero M] [Zero N] [Zero P] [D : DecidableEq α] {f : M → N → P} {hf : f 0 0 = 0} {g₁ : α →₀ M} {g₂ : α →₀ N}
Goal: (Finsupp.zipWith f hf g₁ g₂).support ⊆ g₁.support ∪ g₂.support
-- Finsupp.zipWith_single_single
@[simp]
theorem zipWith_single_single (f : M → N → P) (hf : f 0 0 = 0) (a : α) (m : M) (n : N) :
    zipWith f hf (single a m) (single a n) = single a (f m n) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} {P : Type u_8} [Zero M] [Zero N] [Zero P] (f : M → N → P) (hf : f 0 0 = 0) (a : α) (m : M) (n : N)
Goal: Finsupp.zipWith f hf (Finsupp.single a m) (Finsupp.single a n) = Finsupp.single a (f m n)
-- Finsupp.coe_add
@[simp, norm_cast] lemma coe_add (f g : α →₀ M) : ⇑(f + g) = f + g 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] (f g : α →₀ M)
Goal: ⇑(f + g) = ⇑f + ⇑g
-- Finsupp.add_apply
theorem add_apply (g₁ g₂ : α →₀ M) (a : α) : (g₁ + g₂) a = g₁ a + g₂ a 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] (g₁ g₂ : α →₀ M) (a : α)
Goal: (g₁ + g₂) a = g₁ a + g₂ a
-- Finsupp.support_add
theorem support_add [DecidableEq α] {g₁ g₂ : α →₀ M} :
    (g₁ + g₂).support ⊆ g₁.support ∪ g₂.support 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] [DecidableEq α] {g₁ g₂ : α →₀ M}
Goal: (g₁ + g₂).support ⊆ g₁.support ∪ g₂.support
-- Finsupp.support_add_eq
theorem support_add_eq [DecidableEq α] {g₁ g₂ : α →₀ M} (h : Disjoint g₁.support g₂.support) :
    (g₁ + g₂).support = g₁.support ∪ g₂.support 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] [DecidableEq α] {g₁ g₂ : α →₀ M} (h : Disjoint g₁.support g₂.support)
Goal: (g₁ + g₂).support = g₁.support ∪ g₂.support
-- Finsupp.single_add
@[simp]
theorem single_add (a : α) (b₁ b₂ : M) : single a (b₁ + b₂) = single a b₁ + single a b₂ 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] (a : α) (b₁ b₂ : M)
Goal: Finsupp.single a (b₁ + b₂) = Finsupp.single a b₁ + Finsupp.single a b₂
-- AddEquiv.finsuppUnique_symm
lemma _root_.AddEquiv.finsuppUnique_symm {M : Type*} [AddZeroClass M] (d : M) :
    AddEquiv.finsuppUnique.symm d = single () d 
Arguments: {M : Type u_13} [AddZeroClass M] (d : M)
Goal: AddEquiv.finsuppUnique.symm d = Finsupp.single () d
-- Finsupp.singleAddHom_apply
@[simps]
def singleAddHom (a : α) : M →+ α →₀ M 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] (a : α) (b : M)
Goal: (Finsupp.singleAddHom a) b = Finsupp.single a b
-- Finsupp.applyAddHom_apply
@[simps apply]
def applyAddHom (a : α) : (α →₀ M) →+ M 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] (a : α) (g : α →₀ M)
Goal: (Finsupp.applyAddHom a) g = g a
-- Finsupp.coeFnAddHom_apply
@[simps]
noncomputable def coeFnAddHom : (α →₀ M) →+ α → M 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M]
Goal: ∀ (a : α →₀ M) (a_1 : α), Finsupp.coeFnAddHom a a_1 = a a_1
-- Finsupp.update_eq_single_add_erase
theorem update_eq_single_add_erase (f : α →₀ M) (a : α) (b : M) :
    f.update a b = single a b + f.erase a 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] (f : α →₀ M) (a : α) (b : M)
Goal: f.update a b = Finsupp.single a b + Finsupp.erase a f
-- Finsupp.update_eq_erase_add_single
theorem update_eq_erase_add_single (f : α →₀ M) (a : α) (b : M) :
    f.update a b = f.erase a + single a b 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] (f : α →₀ M) (a : α) (b : M)
Goal: f.update a b = Finsupp.erase a f + Finsupp.single a b
-- Finsupp.single_add_erase
theorem single_add_erase (a : α) (f : α →₀ M) : single a (f a) + f.erase a = f 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] (a : α) (f : α →₀ M)
Goal: Finsupp.single a (f a) + Finsupp.erase a f = f
-- Finsupp.erase_add_single
theorem erase_add_single (a : α) (f : α →₀ M) : f.erase a + single a (f a) = f 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] (a : α) (f : α →₀ M)
Goal: Finsupp.erase a f + Finsupp.single a (f a) = f
-- Finsupp.erase_add
@[simp]
theorem erase_add (a : α) (f f' : α →₀ M) : erase a (f + f') = erase a f + erase a f' 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] (a : α) (f f' : α →₀ M)
Goal: Finsupp.erase a (f + f') = Finsupp.erase a f + Finsupp.erase a f'
-- Finsupp.eraseAddHom_apply
@[simps]
def eraseAddHom (a : α) : (α →₀ M) →+ α →₀ M 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] (a : α) (f : α →₀ M)
Goal: (Finsupp.eraseAddHom a) f = Finsupp.erase a f
-- Finsupp.induction
@[elab_as_elim]
protected theorem induction {p : (α →₀ M) → Prop} (f : α →₀ M) (h0 : p 0)
    (ha : ∀ (a b) (f : α →₀ M), a ∉ f.support → b ≠ 0 → p f → p (single a b + f)) : p f 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] {p : (α →₀ M) → Prop} (f : α →₀ M) (h0 : p 0) (ha : ∀ (a : α) (b : M) (f : α →₀ M), a ∉ f.support → b ≠ 0 → p f → p (Finsupp.single a b + f))
Goal: p f
-- Finsupp.induction₂
theorem induction₂ {p : (α →₀ M) → Prop} (f : α →₀ M) (h0 : p 0)
    (ha : ∀ (a b) (f : α →₀ M), a ∉ f.support → b ≠ 0 → p f → p (f + single a b)) : p f 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] {p : (α →₀ M) → Prop} (f : α →₀ M) (h0 : p 0) (ha : ∀ (a : α) (b : M) (f : α →₀ M), a ∉ f.support → b ≠ 0 → p f → p (f + Finsupp.single a b))
Goal: p f
-- Finsupp.induction_linear
theorem induction_linear {p : (α →₀ M) → Prop} (f : α →₀ M) (h0 : p 0)
    (hadd : ∀ f g : α →₀ M, p f → p g → p (f + g)) (hsingle : ∀ a b, p (single a b)) : p f 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] {p : (α →₀ M) → Prop} (f : α →₀ M) (h0 : p 0) (hadd : ∀ (f g : α →₀ M), p f → p g → p (f + g)) (hsingle : ∀ (a : α) (b : M), p (Finsupp.single a b))
Goal: p f
-- Finsupp.add_closure_setOf_eq_single
@[simp]
theorem add_closure_setOf_eq_single :
    AddSubmonoid.closure { f : α →₀ M | ∃ a b, f = single a b } = ⊤ 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M]
Goal: AddSubmonoid.closure {f | ∃ a b, f = Finsupp.single a b} = ⊤
-- Finsupp.addHom_ext
theorem addHom_ext [AddZeroClass N] ⦃f g : (α →₀ M) →+ N⦄
    (H : ∀ x y, f (single x y) = g (single x y)) : f = g 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [AddZeroClass M] [AddZeroClass N] ⦃f g : (α →₀ M) →+ N⦄ (H : ∀ (x : α) (y : M), f (Finsupp.single x y) = g (Finsupp.single x y))
Goal: f = g
-- Finsupp.addHom_ext'
@[ext high]
theorem addHom_ext' [AddZeroClass N] ⦃f g : (α →₀ M) →+ N⦄
    (H : ∀ x, f.comp (singleAddHom x) = g.comp (singleAddHom x)) : f = g 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [AddZeroClass M] [AddZeroClass N] ⦃f g : (α →₀ M) →+ N⦄ (H : ∀ (x : α), f.comp (Finsupp.singleAddHom x) = g.comp (Finsupp.singleAddHom x))
Goal: f = g
-- Finsupp.mulHom_ext
theorem mulHom_ext [MulOneClass N] ⦃f g : Multiplicative (α →₀ M) →* N⦄
    (H : ∀ x y, f (Multiplicative.ofAdd <| single x y) = g (Multiplicative.ofAdd <| single x y)) :
    f = g 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [AddZeroClass M] [MulOneClass N] ⦃f g : Multiplicative (α →₀ M) →* N⦄ (H : ∀ (x : α) (y : M), f (Multiplicative.ofAdd (Finsupp.single x y)) = g (Multiplicative.ofAdd (Finsupp.single x y)))
Goal: f = g
-- Finsupp.mulHom_ext'
@[ext]
theorem mulHom_ext' [MulOneClass N] {f g : Multiplicative (α →₀ M) →* N}
    (H : ∀ x, f.comp (AddMonoidHom.toMultiplicative (singleAddHom x)) =
              g.comp (AddMonoidHom.toMultiplicative (singleAddHom x))) :
    f = g 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [AddZeroClass M] [MulOneClass N] {f g : Multiplicative (α →₀ M) →* N} (H :
  ∀ (x : α),
    f.comp (AddMonoidHom.toMultiplicative (Finsupp.singleAddHom x)) =
      g.comp (AddMonoidHom.toMultiplicative (Finsupp.singleAddHom x)))
Goal: f = g
-- Finsupp.mapRange_add
theorem mapRange_add [AddZeroClass N] {f : M → N} {hf : f 0 = 0}
    (hf' : ∀ x y, f (x + y) = f x + f y) (v₁ v₂ : α →₀ M) :
    mapRange f hf (v₁ + v₂) = mapRange f hf v₁ + mapRange f hf v₂ 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [AddZeroClass M] [AddZeroClass N] {f : M → N} {hf : f 0 = 0} (hf' : ∀ (x y : M), f (x + y) = f x + f y) (v₁ v₂ : α →₀ M)
Goal: Finsupp.mapRange f hf (v₁ + v₂) = Finsupp.mapRange f hf v₁ + Finsupp.mapRange f hf v₂
-- Finsupp.mapRange_add'
theorem mapRange_add' [AddZeroClass N] [FunLike β M N] [AddMonoidHomClass β M N]
    {f : β} (v₁ v₂ : α →₀ M) :
    mapRange f (map_zero f) (v₁ + v₂) = mapRange f (map_zero f) v₁ + mapRange f (map_zero f) v₂ 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_7} [AddZeroClass M] [AddZeroClass N] [FunLike β M N] [AddMonoidHomClass β M N] {f : β} (v₁ v₂ : α →₀ M)
Goal: Finsupp.mapRange ⇑f ⋯ (v₁ + v₂) = Finsupp.mapRange ⇑f ⋯ v₁ + Finsupp.mapRange ⇑f ⋯ v₂
-- Finsupp.embDomain.addMonoidHom_apply
@[simps]
def embDomain.addMonoidHom (f : α ↪ β) : (α →₀ M) →+ β →₀ M 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddZeroClass M] (f : α ↪ β) (v : α →₀ M)
Goal: (Finsupp.embDomain.addMonoidHom f) v = Finsupp.embDomain f v
-- Finsupp.embDomain_add
@[simp]
theorem embDomain_add (f : α ↪ β) (v w : α →₀ M) :
    embDomain f (v + w) = embDomain f v + embDomain f w 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddZeroClass M] (f : α ↪ β) (v w : α →₀ M)
Goal: Finsupp.embDomain f (v + w) = Finsupp.embDomain f v + Finsupp.embDomain f w
-- Finsupp.coe_neg
@[simp, norm_cast] lemma coe_neg [NegZeroClass G] (g : α →₀ G) : ⇑(-g) = -g 
Arguments: {α : Type u_1} {G : Type u_9} [NegZeroClass G] (g : α →₀ G)
Goal: ⇑(-g) = -⇑g
-- Finsupp.neg_apply
theorem neg_apply [NegZeroClass G] (g : α →₀ G) (a : α) : (-g) a = -g a 
Arguments: {α : Type u_1} {G : Type u_9} [NegZeroClass G] (g : α →₀ G) (a : α)
Goal: (-g) a = -g a
-- Finsupp.mapRange_neg
theorem mapRange_neg [NegZeroClass G] [NegZeroClass H] {f : G → H} {hf : f 0 = 0}
    (hf' : ∀ x, f (-x) = -f x) (v : α →₀ G) : mapRange f hf (-v) = -mapRange f hf v 
Arguments: {α : Type u_1} {G : Type u_9} {H : Type u_10} [NegZeroClass G] [NegZeroClass H] {f : G → H} {hf : f 0 = 0} (hf' : ∀ (x : G), f (-x) = -f x) (v : α →₀ G)
Goal: Finsupp.mapRange f hf (-v) = -Finsupp.mapRange f hf v
-- Finsupp.mapRange_neg'
theorem mapRange_neg' [AddGroup G] [SubtractionMonoid H] [FunLike β G H] [AddMonoidHomClass β G H]
    {f : β} (v : α →₀ G) :
    mapRange f (map_zero f) (-v) = -mapRange f (map_zero f) v 
Arguments: {α : Type u_1} {β : Type u_2} {G : Type u_9} {H : Type u_10} [AddGroup G] [SubtractionMonoid H] [FunLike β G H] [AddMonoidHomClass β G H] {f : β} (v : α →₀ G)
Goal: Finsupp.mapRange ⇑f ⋯ (-v) = -Finsupp.mapRange ⇑f ⋯ v
-- Finsupp.coe_sub
@[simp, norm_cast] lemma coe_sub [SubNegZeroMonoid G] (g₁ g₂ : α →₀ G) : ⇑(g₁ - g₂) = g₁ - g₂ 
Arguments: {α : Type u_1} {G : Type u_9} [SubNegZeroMonoid G] (g₁ g₂ : α →₀ G)
Goal: ⇑(g₁ - g₂) = ⇑g₁ - ⇑g₂
-- Finsupp.sub_apply
theorem sub_apply [SubNegZeroMonoid G] (g₁ g₂ : α →₀ G) (a : α) : (g₁ - g₂) a = g₁ a - g₂ a 
Arguments: {α : Type u_1} {G : Type u_9} [SubNegZeroMonoid G] (g₁ g₂ : α →₀ G) (a : α)
Goal: (g₁ - g₂) a = g₁ a - g₂ a
-- Finsupp.mapRange_sub
theorem mapRange_sub [SubNegZeroMonoid G] [SubNegZeroMonoid H] {f : G → H} {hf : f 0 = 0}
    (hf' : ∀ x y, f (x - y) = f x - f y) (v₁ v₂ : α →₀ G) :
    mapRange f hf (v₁ - v₂) = mapRange f hf v₁ - mapRange f hf v₂ 
Arguments: {α : Type u_1} {G : Type u_9} {H : Type u_10} [SubNegZeroMonoid G] [SubNegZeroMonoid H] {f : G → H} {hf : f 0 = 0} (hf' : ∀ (x y : G), f (x - y) = f x - f y) (v₁ v₂ : α →₀ G)
Goal: Finsupp.mapRange f hf (v₁ - v₂) = Finsupp.mapRange f hf v₁ - Finsupp.mapRange f hf v₂
-- Finsupp.mapRange_sub'
theorem mapRange_sub' [AddGroup G] [SubtractionMonoid H] [FunLike β G H] [AddMonoidHomClass β G H]
    {f : β} (v₁ v₂ : α →₀ G) :
    mapRange f (map_zero f) (v₁ - v₂) = mapRange f (map_zero f) v₁ - mapRange f (map_zero f) v₂ 
Arguments: {α : Type u_1} {β : Type u_2} {G : Type u_9} {H : Type u_10} [AddGroup G] [SubtractionMonoid H] [FunLike β G H] [AddMonoidHomClass β G H] {f : β} (v₁ v₂ : α →₀ G)
Goal: Finsupp.mapRange ⇑f ⋯ (v₁ - v₂) = Finsupp.mapRange ⇑f ⋯ v₁ - Finsupp.mapRange ⇑f ⋯ v₂
-- Finsupp.single_add_single_eq_single_add_single
theorem single_add_single_eq_single_add_single [AddCommMonoid M] {k l m n : α} {u v : M}
    (hu : u ≠ 0) (hv : v ≠ 0) :
    single k u + single l v = single m u + single n v ↔
      (k = m ∧ l = n) ∨ (u = v ∧ k = n ∧ l = m) ∨ (u + v = 0 ∧ k = l ∧ m = n) 
Arguments: {α : Type u_1} {M : Type u_5} [AddCommMonoid M] {k l m n : α} {u v : M} (hu : u ≠ 0) (hv : v ≠ 0)
Goal: Finsupp.single k u + Finsupp.single l v = Finsupp.single m u + Finsupp.single n v ↔
  k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u + v = 0 ∧ k = l ∧ m = n
-- Finsupp.support_neg
@[simp]
theorem support_neg [AddGroup G] (f : α →₀ G) : support (-f) = support f 
Arguments: {α : Type u_1} {G : Type u_9} [AddGroup G] (f : α →₀ G)
Goal: (-f).support = f.support
-- Finsupp.support_sub
theorem support_sub [DecidableEq α] [AddGroup G] {f g : α →₀ G} :
    support (f - g) ⊆ support f ∪ support g 
Arguments: {α : Type u_1} {G : Type u_9} [DecidableEq α] [AddGroup G] {f g : α →₀ G}
Goal: (f - g).support ⊆ f.support ∪ g.support
-- Finsupp.erase_eq_sub_single
theorem erase_eq_sub_single [AddGroup G] (f : α →₀ G) (a : α) : f.erase a = f - single a (f a) 
Arguments: {α : Type u_1} {G : Type u_9} [AddGroup G] (f : α →₀ G) (a : α)
Goal: Finsupp.erase a f = f - Finsupp.single a (f a)
-- Finsupp.update_eq_sub_add_single
theorem update_eq_sub_add_single [AddGroup G] (f : α →₀ G) (a : α) (b : G) :
    f.update a b = f - single a (f a) + single a b 
Arguments: {α : Type u_1} {G : Type u_9} [AddGroup G] (f : α →₀ G) (a : α) (b : G)
Goal: f.update a b = f - Finsupp.single a (f a) + Finsupp.single a b
-- Real.exp_one_near_10
theorem exp_one_near_10 : |exp 1 - 2244083 / 825552| ≤ 1 / 10 ^ 10 
Goal: |Real.exp 1 - 2244083 / 825552| ≤ 1 / 10 ^ 10
-- Real.exp_one_near_20
theorem exp_one_near_20 : |exp 1 - 363916618873 / 133877442384| ≤ 1 / 10 ^ 20 
Goal: |Real.exp 1 - 363916618873 / 133877442384| ≤ 1 / 10 ^ 20
-- Real.exp_one_gt_d9
theorem exp_one_gt_d9 : 2.7182818283 < exp 1 
Goal: 2.7182818283 < Real.exp 1
-- Real.exp_one_lt_d9
theorem exp_one_lt_d9 : exp 1 < 2.7182818286 
Goal: Real.exp 1 < 2.7182818286
-- Real.exp_neg_one_gt_d9
theorem exp_neg_one_gt_d9 : 0.36787944116 < exp (-1) 
Goal: 0.36787944116 < Real.exp (-1)
-- Real.exp_neg_one_lt_d9
theorem exp_neg_one_lt_d9 : exp (-1) < 0.3678794412 
Goal: Real.exp (-1) < 0.3678794412
-- Real.log_two_near_10
theorem log_two_near_10 : |log 2 - 287209 / 414355| ≤ 1 / 10 ^ 10 
Goal: |Real.log 2 - 287209 / 414355| ≤ 1 / 10 ^ 10
-- Real.log_two_gt_d9
theorem log_two_gt_d9 : 0.6931471803 < log 2 
Goal: 0.6931471803 < Real.log 2
-- Real.log_two_lt_d9
theorem log_two_lt_d9 : log 2 < 0.6931471808 
Goal: Real.log 2 < 0.6931471808
-- _private.Mathlib.Data.Complex.Abs.0.Complex.AbsTheory.mul_self_abs
private theorem mul_self_abs (z : ℂ) : ((abs z) * abs z) = normSq z 
Arguments: (z : ℂ)
Goal: √(Complex.normSq z) * √(Complex.normSq z) = Complex.normSq z
-- _private.Mathlib.Data.Complex.Abs.0.Complex.AbsTheory.abs_nonneg'
private theorem abs_nonneg' (z : ℂ) : 0 ≤ abs z 
Arguments: (z : ℂ)
Goal: 0 ≤ √(Complex.normSq z)
-- Complex.AbsTheory.abs_conj
theorem abs_conj (z : ℂ) : (abs conj z) = abs z 
Arguments: (z : ℂ)
Goal: √(Complex.normSq ((starRingEnd ℂ) z)) = √(Complex.normSq z)
-- _private.Mathlib.Data.Complex.Abs.0.Complex.AbsTheory.abs_re_le_abs
private theorem abs_re_le_abs (z : ℂ) : |z.re| ≤ abs z 
Arguments: (z : ℂ)
Goal: |z.re| ≤ √(Complex.normSq z)
-- _private.Mathlib.Data.Complex.Abs.0.Complex.AbsTheory.re_le_abs
private theorem re_le_abs (z : ℂ) : z.re ≤ abs z 
Arguments: (z : ℂ)
Goal: z.re ≤ √(Complex.normSq z)
-- _private.Mathlib.Data.Complex.Abs.0.Complex.AbsTheory.abs_mul
private theorem abs_mul (z w : ℂ) : (abs z * w) = (abs z) * abs w 
Arguments: (z w : ℂ)
Goal: √(Complex.normSq (z * w)) = √(Complex.normSq z) * √(Complex.normSq w)