ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Complex.inv_def
theorem inv_def (z : ℂ) : z⁻¹ = conj z * ((normSq z)⁻¹ : ℝ) 
Arguments: (z : ℂ)
Goal: z⁻¹ = (starRingEnd ℂ) z * ↑(Complex.normSq z)⁻¹
-- Complex.inv_re
@[simp]
theorem inv_re (z : ℂ) : z⁻¹.re = z.re / normSq z 
Arguments: (z : ℂ)
Goal: z⁻¹.re = z.re / Complex.normSq z
-- Complex.inv_im
@[simp]
theorem inv_im (z : ℂ) : z⁻¹.im = -z.im / normSq z 
Arguments: (z : ℂ)
Goal: z⁻¹.im = -z.im / Complex.normSq z
-- Complex.ofReal_inv
@[simp, norm_cast]
theorem ofReal_inv (r : ℝ) : ((r⁻¹ : ℝ) : ℂ) = (r : ℂ)⁻¹ 
Arguments: (r : ℝ)
Goal: ↑r⁻¹ = (↑r)⁻¹
-- Complex.inv_zero
protected theorem inv_zero : (0⁻¹ : ℂ) = 0 
Goal: 0⁻¹ = 0
-- Complex.mul_inv_cancel
protected theorem mul_inv_cancel {z : ℂ} (h : z ≠ 0) : z * z⁻¹ = 1 
Arguments: {z : ℂ} (h : z ≠ 0)
Goal: z * z⁻¹ = 1
-- Complex.div_re
lemma div_re (z w : ℂ) : (z / w).re = z.re * w.re / normSq w + z.im * w.im / normSq w 
Arguments: (z w : ℂ)
Goal: (z / w).re = z.re * w.re / Complex.normSq w + z.im * w.im / Complex.normSq w
-- Complex.div_im
lemma div_im (z w : ℂ) : (z / w).im = z.im * w.re / normSq w - z.re * w.im / normSq w 
Arguments: (z w : ℂ)
Goal: (z / w).im = z.im * w.re / Complex.normSq w - z.re * w.im / Complex.normSq w
-- Complex.ofReal_nnqsmul
@[simp, norm_cast]
lemma ofReal_nnqsmul (q : ℚ≥0) (r : ℝ) : ofReal' (q • r) = q • r 
Arguments: (q : ℚ≥0) (r : ℝ)
Goal: ↑(q • r) = q • ↑r
-- Complex.ofReal_qsmul
@[simp, norm_cast]
lemma ofReal_qsmul (q : ℚ) (r : ℝ) : ofReal' (q • r) = q • r 
Arguments: (q : ℚ) (r : ℝ)
Goal: ↑(q • r) = q • ↑r
-- Complex.conj_inv
theorem conj_inv (x : ℂ) : conj x⁻¹ = (conj x)⁻¹ 
Arguments: (x : ℂ)
Goal: (starRingEnd ℂ) x⁻¹ = ((starRingEnd ℂ) x)⁻¹
-- Complex.ofReal_div
@[simp, norm_cast]
theorem ofReal_div (r s : ℝ) : ((r / s : ℝ) : ℂ) = r / s 
Arguments: (r s : ℝ)
Goal: ↑(r / s) = ↑r / ↑s
-- Complex.ofReal_zpow
@[simp, norm_cast]
theorem ofReal_zpow (r : ℝ) (n : ℤ) : ((r ^ n : ℝ) : ℂ) = (r : ℂ) ^ n 
Arguments: (r : ℝ) (n : ℤ)
Goal: ↑(r ^ n) = ↑r ^ n
-- Complex.div_I
@[simp]
theorem div_I (z : ℂ) : z / I = -(z * I) 
Arguments: (z : ℂ)
Goal: z / Complex.I = -(z * Complex.I)
-- Complex.inv_I
@[simp]
theorem inv_I : I⁻¹ = -I 
Goal: Complex.I⁻¹ = -Complex.I
-- Complex.normSq_inv
theorem normSq_inv (z : ℂ) : normSq z⁻¹ = (normSq z)⁻¹ 
Arguments: (z : ℂ)
Goal: Complex.normSq z⁻¹ = (Complex.normSq z)⁻¹
-- Complex.normSq_div
theorem normSq_div (z w : ℂ) : normSq (z / w) = normSq z / normSq w 
Arguments: (z w : ℂ)
Goal: Complex.normSq (z / w) = Complex.normSq z / Complex.normSq w
-- Complex.div_ofReal
lemma div_ofReal (z : ℂ) (x : ℝ) : z / x = ⟨z.re / x, z.im / x⟩ 
Arguments: (z : ℂ) (x : ℝ)
Goal: z / ↑x = { re := z.re / x, im := z.im / x }
-- Complex.div_natCast
lemma div_natCast (z : ℂ) (n : ℕ) : z / n = ⟨z.re / n, z.im / n⟩ 
Arguments: (z : ℂ) (n : ℕ)
Goal: z / ↑n = { re := z.re / ↑n, im := z.im / ↑n }
-- Complex.div_intCast
lemma div_intCast (z : ℂ) (n : ℤ) : z / n = ⟨z.re / n, z.im / n⟩ 
Arguments: (z : ℂ) (n : ℤ)
Goal: z / ↑n = { re := z.re / ↑n, im := z.im / ↑n }
-- Complex.div_ratCast
lemma div_ratCast (z : ℂ) (x : ℚ) : z / x = ⟨z.re / x, z.im / x⟩ 
Arguments: (z : ℂ) (x : ℚ)
Goal: z / ↑x = { re := z.re / ↑x, im := z.im / ↑x }
-- Complex.div_ofNat
lemma div_ofNat (z : ℂ) (n : ℕ) [n.AtLeastTwo] :
    z / OfNat.ofNat n = ⟨z.re / OfNat.ofNat n, z.im / OfNat.ofNat n⟩ 
Arguments: (z : ℂ) (n : ℕ) [n.AtLeastTwo]
Goal: z / OfNat.ofNat n = { re := z.re / OfNat.ofNat n, im := z.im / OfNat.ofNat n }
-- Complex.div_ofReal_re
@[simp] lemma div_ofReal_re (z : ℂ) (x : ℝ) : (z / x).re = z.re / x 
Arguments: (z : ℂ) (x : ℝ)
Goal: (z / ↑x).re = z.re / x
-- Complex.div_ofReal_im
@[simp] lemma div_ofReal_im (z : ℂ) (x : ℝ) : (z / x).im = z.im / x 
Arguments: (z : ℂ) (x : ℝ)
Goal: (z / ↑x).im = z.im / x
-- Complex.div_natCast_re
@[simp] lemma div_natCast_re (z : ℂ) (n : ℕ) : (z / n).re = z.re / n 
Arguments: (z : ℂ) (n : ℕ)
Goal: (z / ↑n).re = z.re / ↑n
-- Complex.div_natCast_im
@[simp] lemma div_natCast_im (z : ℂ) (n : ℕ) : (z / n).im = z.im / n 
Arguments: (z : ℂ) (n : ℕ)
Goal: (z / ↑n).im = z.im / ↑n
-- Complex.div_intCast_re
@[simp] lemma div_intCast_re (z : ℂ) (n : ℤ) : (z / n).re = z.re / n 
Arguments: (z : ℂ) (n : ℤ)
Goal: (z / ↑n).re = z.re / ↑n
-- Complex.div_intCast_im
@[simp] lemma div_intCast_im (z : ℂ) (n : ℤ) : (z / n).im = z.im / n 
Arguments: (z : ℂ) (n : ℤ)
Goal: (z / ↑n).im = z.im / ↑n
-- Complex.div_ratCast_re
@[simp] lemma div_ratCast_re (z : ℂ) (x : ℚ) : (z / x).re = z.re / x 
Arguments: (z : ℂ) (x : ℚ)
Goal: (z / ↑x).re = z.re / ↑x
-- Complex.div_ratCast_im
@[simp] lemma div_ratCast_im (z : ℂ) (x : ℚ) : (z / x).im = z.im / x 
Arguments: (z : ℂ) (x : ℚ)
Goal: (z / ↑x).im = z.im / ↑x
-- Complex.div_ofNat_re
@[simp]
lemma div_ofNat_re (z : ℂ) (n : ℕ) [n.AtLeastTwo] :
    (z / no_index (OfNat.ofNat n)).re = z.re / OfNat.ofNat n 
Arguments: (z : ℂ) (n : ℕ) [n.AtLeastTwo]
Goal: (z / OfNat.ofNat n).re = z.re / OfNat.ofNat n
-- Complex.div_ofNat_im
@[simp]
lemma div_ofNat_im (z : ℂ) (n : ℕ) [n.AtLeastTwo] :
    (z / no_index (OfNat.ofNat n)).im = z.im / OfNat.ofNat n 
Arguments: (z : ℂ) (n : ℕ) [n.AtLeastTwo]
Goal: (z / OfNat.ofNat n).im = z.im / OfNat.ofNat n
-- Complex.re_eq_add_conj
theorem re_eq_add_conj (z : ℂ) : (z.re : ℂ) = (z + conj z) / 2 
Arguments: (z : ℂ)
Goal: ↑z.re = (z + (starRingEnd ℂ) z) / 2
-- Complex.im_eq_sub_conj
theorem im_eq_sub_conj (z : ℂ) : (z.im : ℂ) = (z - conj z) / (2 * I) 
Arguments: (z : ℂ)
Goal: ↑z.im = (z - (starRingEnd ℂ) z) / (2 * Complex.I)
-- Computation.terminates_parallel.aux
theorem terminates_parallel.aux :
    ∀ {l : List (Computation α)} {S c},
      c ∈ l → Terminates c → Terminates (corec parallel.aux1 (l, S)) 
Arguments: {α : Type u} {l : List (Computation α)} {S : Stream'.WSeq (Computation α)} {c : Computation α}
Goal: c ∈ l → c.Terminates → (Computation.corec Computation.parallel.aux1 (l, S)).Terminates
-- Computation.terminates_parallel
theorem terminates_parallel {S : WSeq (Computation α)} {c} (h : c ∈ S) [T : Terminates c] :
    Terminates (parallel S) 
Arguments: {α : Type u} {S : Stream'.WSeq (Computation α)} {c : Computation α} (h : c ∈ S) [T : c.Terminates]
Goal: (Computation.parallel S).Terminates
-- Computation.exists_of_mem_parallel
theorem exists_of_mem_parallel {S : WSeq (Computation α)} {a} (h : a ∈ parallel S) :
    ∃ c ∈ S, a ∈ c 
Arguments: {α : Type u} {S : Stream'.WSeq (Computation α)} {a : α} (h : a ∈ Computation.parallel S)
Goal: ∃ c, c ∈ S ∧ a ∈ c
-- Computation.map_parallel
theorem map_parallel (f : α → β) (S) : map f (parallel S) = parallel (S.map (map f)) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (S : Stream'.WSeq (Computation α))
Goal: Computation.map f (Computation.parallel S) = Computation.parallel (Stream'.WSeq.map (Computation.map f) S)
-- Computation.parallel_empty
theorem parallel_empty (S : WSeq (Computation α)) (h : S.head ~> none) : parallel S = empty _ 
Arguments: {α : Type u} (S : Stream'.WSeq (Computation α)) (h : S.head.Promises none)
Goal: Computation.parallel S = Computation.empty α
-- Computation.parallel_promises
theorem parallel_promises {S : WSeq (Computation α)} {a} (H : ∀ s ∈ S, s ~> a) : parallel S ~> a 
Arguments: {α : Type u} {S : Stream'.WSeq (Computation α)} {a : α} (H : ∀ (s : Computation α), s ∈ S → s.Promises a)
Goal: (Computation.parallel S).Promises a
-- Computation.mem_parallel
theorem mem_parallel {S : WSeq (Computation α)} {a} (H : ∀ s ∈ S, s ~> a) {c} (cs : c ∈ S)
    (ac : a ∈ c) : a ∈ parallel S 
Arguments: {α : Type u} {S : Stream'.WSeq (Computation α)} {a : α} (H : ∀ (s : Computation α), s ∈ S → s.Promises a) {c : Computation α} (cs : c ∈ S) (ac : a ∈ c)
Goal: a ∈ Computation.parallel S
-- Computation.parallel_congr_lem
theorem parallel_congr_lem {S T : WSeq (Computation α)} {a} (H : S.LiftRel Equiv T) :
    (∀ s ∈ S, s ~> a) ↔ ∀ t ∈ T, t ~> a 
Arguments: {α : Type u} {S T : Stream'.WSeq (Computation α)} {a : α} (H : Stream'.WSeq.LiftRel Computation.Equiv S T)
Goal: (∀ (s : Computation α), s ∈ S → s.Promises a) ↔ ∀ (t : Computation α), t ∈ T → t.Promises a
-- Computation.parallel_congr_left
theorem parallel_congr_left {S T : WSeq (Computation α)} {a} (h1 : ∀ s ∈ S, s ~> a)
    (H : S.LiftRel Equiv T) : parallel S ~ parallel T 
Arguments: {α : Type u} {S T : Stream'.WSeq (Computation α)} {a : α} (h1 : ∀ (s : Computation α), s ∈ S → s.Promises a) (H : Stream'.WSeq.LiftRel Computation.Equiv S T)
Goal: (Computation.parallel S).Equiv (Computation.parallel T)
-- Computation.parallel_congr_right
theorem parallel_congr_right {S T : WSeq (Computation α)} {a} (h2 : ∀ t ∈ T, t ~> a)
    (H : S.LiftRel Equiv T) : parallel S ~ parallel T 
Arguments: {α : Type u} {S T : Stream'.WSeq (Computation α)} {a : α} (h2 : ∀ (t : Computation α), t ∈ T → t.Promises a) (H : Stream'.WSeq.LiftRel Computation.Equiv S T)
Goal: (Computation.parallel S).Equiv (Computation.parallel T)
-- Finsupp.mk_mem_graph_iff
theorem mk_mem_graph_iff {a : α} {m : M} {f : α →₀ M} : (a, m) ∈ f.graph ↔ f a = m ∧ m ≠ 0 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {a : α} {m : M} {f : α →₀ M}
Goal: (a, m) ∈ f.graph ↔ f a = m ∧ m ≠ 0
-- Finsupp.mem_graph_iff
@[simp]
theorem mem_graph_iff {c : α × M} {f : α →₀ M} : c ∈ f.graph ↔ f c.1 = c.2 ∧ c.2 ≠ 0 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {c : α × M} {f : α →₀ M}
Goal: c ∈ f.graph ↔ f c.1 = c.2 ∧ c.2 ≠ 0
-- Finsupp.mk_mem_graph
theorem mk_mem_graph (f : α →₀ M) {a : α} (ha : a ∈ f.support) : (a, f a) ∈ f.graph 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (f : α →₀ M) {a : α} (ha : a ∈ f.support)
Goal: (a, f a) ∈ f.graph
-- Finsupp.apply_eq_of_mem_graph
theorem apply_eq_of_mem_graph {a : α} {m : M} {f : α →₀ M} (h : (a, m) ∈ f.graph) : f a = m 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {a : α} {m : M} {f : α →₀ M} (h : (a, m) ∈ f.graph)
Goal: f a = m
-- Finsupp.not_mem_graph_snd_zero
@[simp 1100] -- Porting note: change priority to appease `simpNF`
theorem not_mem_graph_snd_zero (a : α) (f : α →₀ M) : (a, (0 : M)) ∉ f.graph 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (a : α) (f : α →₀ M)
Goal: (a, 0) ∉ f.graph
-- Finsupp.image_fst_graph
@[simp]
theorem image_fst_graph [DecidableEq α] (f : α →₀ M) : f.graph.image Prod.fst = f.support 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] [DecidableEq α] (f : α →₀ M)
Goal: Finset.image Prod.fst f.graph = f.support
-- Finsupp.graph_injective
theorem graph_injective (α M) [Zero M] : Injective (@graph α M _) 
Arguments: (α : Type u_13) (M : Type u_14) [Zero M]
Goal: Function.Injective Finsupp.graph
-- Finsupp.graph_inj
@[simp]
theorem graph_inj {f g : α →₀ M} : f.graph = g.graph ↔ f = g 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {f g : α →₀ M}
Goal: f.graph = g.graph ↔ f = g
-- Finsupp.graph_zero
@[simp]
theorem graph_zero : graph (0 : α →₀ M) = ∅ 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M]
Goal: Finsupp.graph 0 = ∅
-- Finsupp.graph_eq_empty
@[simp]
theorem graph_eq_empty {f : α →₀ M} : f.graph = ∅ ↔ f = 0 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] {f : α →₀ M}
Goal: f.graph = ∅ ↔ f = 0
-- Finsupp.mapRange.equiv_apply
@[simps apply]
def mapRange.equiv (f : M ≃ N) (hf : f 0 = 0) (hf' : f.symm 0 = 0) : (α →₀ M) ≃ (α →₀ N) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [Zero M] [Zero N] (f : M ≃ N) (hf : f 0 = 0) (hf' : f.symm 0 = 0) (g : α →₀ M)
Goal: (Finsupp.mapRange.equiv f hf hf') g = Finsupp.mapRange (⇑f) hf g
-- Finsupp.mapRange.equiv_refl
@[simp]
theorem mapRange.equiv_refl : mapRange.equiv (Equiv.refl M) rfl rfl = Equiv.refl (α →₀ M) 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M]
Goal: Finsupp.mapRange.equiv (Equiv.refl M) ⋯ ⋯ = Equiv.refl (α →₀ M)
-- Finsupp.mapRange.equiv_trans
theorem mapRange.equiv_trans (f : M ≃ N) (hf : f 0 = 0) (hf') (f₂ : N ≃ P) (hf₂ : f₂ 0 = 0) (hf₂') :
    (mapRange.equiv (f.trans f₂) (by rw [Equiv.trans_apply, hf, hf₂])
          (by rw [Equiv.symm_trans_apply, hf₂', hf']) :
        (α →₀ _) ≃ _) =
      (mapRange.equiv f hf hf').trans (mapRange.equiv f₂ hf₂ hf₂') 
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) (hf : f 0 = 0) (hf' : f.symm 0 = 0) (f₂ : N ≃ P) (hf₂ : f₂ 0 = 0) (hf₂' : f₂.symm 0 = 0)
Goal: Finsupp.mapRange.equiv (f.trans f₂) ⋯ ⋯ = (Finsupp.mapRange.equiv f hf hf').trans (Finsupp.mapRange.equiv f₂ hf₂ hf₂')
-- Finsupp.mapRange.equiv_symm
@[simp]
theorem mapRange.equiv_symm (f : M ≃ N) (hf hf') :
    ((mapRange.equiv f hf hf').symm : (α →₀ _) ≃ _) = mapRange.equiv f.symm hf' hf 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [Zero M] [Zero N] (f : M ≃ N) (hf : f 0 = 0) (hf' : f.symm 0 = 0)
Goal: (Finsupp.mapRange.equiv f hf hf').symm = Finsupp.mapRange.equiv f.symm hf' hf
-- Finsupp.mapRange.zeroHom_apply
@[simps]
def mapRange.zeroHom (f : ZeroHom M N) : ZeroHom (α →₀ M) (α →₀ N) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [Zero M] [Zero N] (f : ZeroHom M N) (g : α →₀ M)
Goal: (Finsupp.mapRange.zeroHom f) g = Finsupp.mapRange ⇑f ⋯ g
-- Finsupp.mapRange.zeroHom_id
@[simp]
theorem mapRange.zeroHom_id : mapRange.zeroHom (ZeroHom.id M) = ZeroHom.id (α →₀ M) 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M]
Goal: Finsupp.mapRange.zeroHom (ZeroHom.id M) = ZeroHom.id (α →₀ M)
-- Finsupp.mapRange.zeroHom_comp
theorem mapRange.zeroHom_comp (f : ZeroHom N P) (f₂ : ZeroHom M N) :
    (mapRange.zeroHom (f.comp f₂) : ZeroHom (α →₀ _) _) =
      (mapRange.zeroHom f).comp (mapRange.zeroHom f₂) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} {P : Type u_8} [Zero M] [Zero N] [Zero P] (f : ZeroHom N P) (f₂ : ZeroHom M N)
Goal: Finsupp.mapRange.zeroHom (f.comp f₂) = (Finsupp.mapRange.zeroHom f).comp (Finsupp.mapRange.zeroHom f₂)
-- Finsupp.mapRange.addMonoidHom_apply
@[simps]
def mapRange.addMonoidHom (f : M →+ N) : (α →₀ M) →+ α →₀ N 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [AddCommMonoid N] (f : M →+ N) (g : α →₀ M)
Goal: (Finsupp.mapRange.addMonoidHom f) g = Finsupp.mapRange ⇑f ⋯ g
-- Finsupp.mapRange.addMonoidHom_id
@[simp]
theorem mapRange.addMonoidHom_id :
    mapRange.addMonoidHom (AddMonoidHom.id M) = AddMonoidHom.id (α →₀ M) 
Arguments: {α : Type u_1} {M : Type u_5} [AddCommMonoid M]
Goal: Finsupp.mapRange.addMonoidHom (AddMonoidHom.id M) = AddMonoidHom.id (α →₀ M)
-- Finsupp.mapRange.addMonoidHom_comp
theorem mapRange.addMonoidHom_comp (f : N →+ P) (f₂ : M →+ N) :
    (mapRange.addMonoidHom (f.comp f₂) : (α →₀ _) →+ _) =
      (mapRange.addMonoidHom f).comp (mapRange.addMonoidHom f₂) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} {P : Type u_8} [AddCommMonoid M] [AddCommMonoid N] [AddCommMonoid P] (f : N →+ P) (f₂ : M →+ N)
Goal: Finsupp.mapRange.addMonoidHom (f.comp f₂) = (Finsupp.mapRange.addMonoidHom f).comp (Finsupp.mapRange.addMonoidHom f₂)
-- Finsupp.mapRange.addMonoidHom_toZeroHom
@[simp]
theorem mapRange.addMonoidHom_toZeroHom (f : M →+ N) :
    (mapRange.addMonoidHom f).toZeroHom = (mapRange.zeroHom f.toZeroHom : ZeroHom (α →₀ _) _) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [AddCommMonoid N] (f : M →+ N)
Goal: ↑(Finsupp.mapRange.addMonoidHom f) = Finsupp.mapRange.zeroHom ↑f
-- Finsupp.mapRange_multiset_sum
theorem mapRange_multiset_sum (f : F) (m : Multiset (α →₀ M)) :
    mapRange f (map_zero f) m.sum = (m.map fun x => mapRange f (map_zero f) x).sum 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [AddCommMonoid N] {F : Type u_13} [FunLike F M N] [AddMonoidHomClass F M N] (f : F) (m : Multiset (α →₀ M))
Goal: Finsupp.mapRange ⇑f ⋯ m.sum = (Multiset.map (fun x => Finsupp.mapRange ⇑f ⋯ x) m).sum
-- Finsupp.mapRange_finset_sum
theorem mapRange_finset_sum (f : F) (s : Finset ι) (g : ι → α →₀ M) :
    mapRange f (map_zero f) (∑ x ∈ s, g x) = ∑ x ∈ s, mapRange f (map_zero f) (g x) 
Arguments: {α : Type u_1} {ι : Type u_4} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [AddCommMonoid N] {F : Type u_13} [FunLike F M N] [AddMonoidHomClass F M N] (f : F) (s : Finset ι) (g : ι → α →₀ M)
Goal: Finsupp.mapRange ⇑f ⋯ (∑ x ∈ s, g x) = ∑ x ∈ s, Finsupp.mapRange ⇑f ⋯ (g x)
-- Finsupp.mapRange.addEquiv_apply
@[simps apply]
def mapRange.addEquiv (f : M ≃+ N) : (α →₀ M) ≃+ (α →₀ N) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [AddCommMonoid N] (f : M ≃+ N) (g : α →₀ M)
Goal: (Finsupp.mapRange.addEquiv f) g = Finsupp.mapRange ⇑f ⋯ g
-- Finsupp.mapRange.addEquiv_refl
@[simp]
theorem mapRange.addEquiv_refl : mapRange.addEquiv (AddEquiv.refl M) = AddEquiv.refl (α →₀ M) 
Arguments: {α : Type u_1} {M : Type u_5} [AddCommMonoid M]
Goal: Finsupp.mapRange.addEquiv (AddEquiv.refl M) = AddEquiv.refl (α →₀ M)
-- Finsupp.mapRange.addEquiv_trans
theorem mapRange.addEquiv_trans (f : M ≃+ N) (f₂ : N ≃+ P) :
    (mapRange.addEquiv (f.trans f₂) : (α →₀ M) ≃+ (α →₀ P)) =
      (mapRange.addEquiv f).trans (mapRange.addEquiv f₂) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} {P : Type u_8} [AddCommMonoid M] [AddCommMonoid N] [AddCommMonoid P] (f : M ≃+ N) (f₂ : N ≃+ P)
Goal: Finsupp.mapRange.addEquiv (f.trans f₂) = (Finsupp.mapRange.addEquiv f).trans (Finsupp.mapRange.addEquiv f₂)
-- Finsupp.mapRange.addEquiv_symm
@[simp]
theorem mapRange.addEquiv_symm (f : M ≃+ N) :
    ((mapRange.addEquiv f).symm : (α →₀ _) ≃+ _) = mapRange.addEquiv f.symm 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [AddCommMonoid N] (f : M ≃+ N)
Goal: (Finsupp.mapRange.addEquiv f).symm = Finsupp.mapRange.addEquiv f.symm
-- Finsupp.mapRange.addEquiv_toAddMonoidHom
@[simp]
theorem mapRange.addEquiv_toAddMonoidHom (f : M ≃+ N) :
    ((mapRange.addEquiv f : (α →₀ _) ≃+ _) : _ →+ _) =
      (mapRange.addMonoidHom f.toAddMonoidHom : (α →₀ _) →+ _) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [AddCommMonoid N] (f : M ≃+ N)
Goal: ↑(Finsupp.mapRange.addEquiv f) = Finsupp.mapRange.addMonoidHom f.toAddMonoidHom
-- Finsupp.mapRange.addEquiv_toEquiv
@[simp]
theorem mapRange.addEquiv_toEquiv (f : M ≃+ N) :
    ↑(mapRange.addEquiv f : (α →₀ _) ≃+ _) =
      (mapRange.equiv (f : M ≃ N) f.map_zero f.symm.map_zero : (α →₀ _) ≃ _) 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [AddCommMonoid M] [AddCommMonoid N] (f : M ≃+ N)
Goal: ↑(Finsupp.mapRange.addEquiv f) = Finsupp.mapRange.equiv ↑f ⋯ ⋯
-- Finsupp.equivMapDomain_apply
@[simp]
theorem equivMapDomain_apply (f : α ≃ β) (l : α →₀ M) (b : β) :
    equivMapDomain f l b = l (f.symm b) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α ≃ β) (l : α →₀ M) (b : β)
Goal: (Finsupp.equivMapDomain f l) b = l (f.symm b)
-- Finsupp.equivMapDomain_symm_apply
theorem equivMapDomain_symm_apply (f : α ≃ β) (l : β →₀ M) (a : α) :
    equivMapDomain f.symm l a = l (f a) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α ≃ β) (l : β →₀ M) (a : α)
Goal: (Finsupp.equivMapDomain f.symm l) a = l (f a)
-- Finsupp.equivMapDomain_refl
@[simp]
theorem equivMapDomain_refl (l : α →₀ M) : equivMapDomain (Equiv.refl _) l = l 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M] (l : α →₀ M)
Goal: Finsupp.equivMapDomain (Equiv.refl α) l = l
-- Finsupp.equivMapDomain_refl'
theorem equivMapDomain_refl' : equivMapDomain (Equiv.refl _) = @id (α →₀ M) 
Arguments: {α : Type u_1} {M : Type u_5} [Zero M]
Goal: Finsupp.equivMapDomain (Equiv.refl α) = id
-- Finsupp.equivMapDomain_trans
theorem equivMapDomain_trans (f : α ≃ β) (g : β ≃ γ) (l : α →₀ M) :
    equivMapDomain (f.trans g) l = equivMapDomain g (equivMapDomain f l) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {M : Type u_5} [Zero M] (f : α ≃ β) (g : β ≃ γ) (l : α →₀ M)
Goal: Finsupp.equivMapDomain (f.trans g) l = Finsupp.equivMapDomain g (Finsupp.equivMapDomain f l)
-- Finsupp.equivMapDomain_trans'
theorem equivMapDomain_trans' (f : α ≃ β) (g : β ≃ γ) :
    @equivMapDomain _ _ M _ (f.trans g) = equivMapDomain g ∘ equivMapDomain f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {M : Type u_5} [Zero M] (f : α ≃ β) (g : β ≃ γ)
Goal: Finsupp.equivMapDomain (f.trans g) = Finsupp.equivMapDomain g ∘ Finsupp.equivMapDomain f
-- Finsupp.equivMapDomain_single
@[simp]
theorem equivMapDomain_single (f : α ≃ β) (a : α) (b : M) :
    equivMapDomain f (single a b) = single (f a) b 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α ≃ β) (a : α) (b : M)
Goal: Finsupp.equivMapDomain f (Finsupp.single a b) = Finsupp.single (f a) b
-- Finsupp.equivMapDomain_zero
@[simp]
theorem equivMapDomain_zero {f : α ≃ β} : equivMapDomain f (0 : α →₀ M) = (0 : β →₀ M) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] {f : α ≃ β}
Goal: Finsupp.equivMapDomain f 0 = 0
-- Finsupp.sum_equivMapDomain
@[to_additive (attr := simp)]
theorem prod_equivMapDomain [CommMonoid N] (f : α ≃ β) (l : α →₀ M) (g : β → M → N) :
    prod (equivMapDomain f l) g = prod l (fun a m => g (f a) m) 
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)
Goal: (Finsupp.equivMapDomain f l).sum g = l.sum fun a m => g (f a) m
-- Finsupp.prod_equivMapDomain
@[to_additive (attr := simp)]
theorem prod_equivMapDomain [CommMonoid N] (f : α ≃ β) (l : α →₀ M) (g : β → M → N) :
    prod (equivMapDomain f l) g = prod l (fun a m => g (f a) m) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_7} [Zero M] [CommMonoid N] (f : α ≃ β) (l : α →₀ M) (g : β → M → N)
Goal: (Finsupp.equivMapDomain f l).prod g = l.prod fun a m => g (f a) m
-- Finsupp.equivCongrLeft_apply
@[simp]
theorem equivCongrLeft_apply (f : α ≃ β) (l : α →₀ M) : equivCongrLeft f l = equivMapDomain f l 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α ≃ β) (l : α →₀ M)
Goal: (Finsupp.equivCongrLeft f) l = Finsupp.equivMapDomain f l
-- Finsupp.equivCongrLeft_symm
@[simp]
theorem equivCongrLeft_symm (f : α ≃ β) :
    (@equivCongrLeft _ _ M _ f).symm = equivCongrLeft f.symm 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α ≃ β)
Goal: (Finsupp.equivCongrLeft f).symm = Finsupp.equivCongrLeft f.symm
-- Nat.cast_finsupp_prod
@[simp, norm_cast]
theorem cast_finsupp_prod [CommSemiring R] (g : α → M → ℕ) :
    (↑(f.prod g) : R) = f.prod fun a b => ↑(g a b) 
Arguments: {α : Type u_1} {M : Type u_5} {R : Type u_11} [Zero M] (f : α →₀ M) [CommSemiring R] (g : α → M → ℕ)
Goal: ↑(f.prod g) = f.prod fun a b => ↑(g a b)
-- Nat.cast_finsupp_sum
@[simp, norm_cast]
theorem cast_finsupp_sum [CommSemiring R] (g : α → M → ℕ) :
    (↑(f.sum g) : R) = f.sum fun a b => ↑(g a b) 
Arguments: {α : Type u_1} {M : Type u_5} {R : Type u_11} [Zero M] (f : α →₀ M) [CommSemiring R] (g : α → M → ℕ)
Goal: ↑(f.sum g) = f.sum fun a b => ↑(g a b)
-- Int.cast_finsupp_prod
@[simp, norm_cast]
theorem cast_finsupp_prod [CommRing R] (g : α → M → ℤ) :
    (↑(f.prod g) : R) = f.prod fun a b => ↑(g a b) 
Arguments: {α : Type u_1} {M : Type u_5} {R : Type u_11} [Zero M] (f : α →₀ M) [CommRing R] (g : α → M → ℤ)
Goal: ↑(f.prod g) = f.prod fun a b => ↑(g a b)
-- Int.cast_finsupp_sum
@[simp, norm_cast]
theorem cast_finsupp_sum [CommRing R] (g : α → M → ℤ) :
    (↑(f.sum g) : R) = f.sum fun a b => ↑(g a b) 
Arguments: {α : Type u_1} {M : Type u_5} {R : Type u_11} [Zero M] (f : α →₀ M) [CommRing R] (g : α → M → ℤ)
Goal: ↑(f.sum g) = f.sum fun a b => ↑(g a b)
-- Rat.cast_finsupp_sum
@[simp, norm_cast]
theorem cast_finsupp_sum [DivisionRing R] [CharZero R] (g : α → M → ℚ) :
    (↑(f.sum g) : R) = f.sum fun a b => ↑(g a b) 
Arguments: {α : Type u_1} {M : Type u_5} {R : Type u_11} [Zero M] (f : α →₀ M) [DivisionRing R] [CharZero R] (g : α → M → ℚ)
Goal: ↑(f.sum g) = f.sum fun a b => ↑(g a b)
-- Rat.cast_finsupp_prod
@[simp, norm_cast]
theorem cast_finsupp_prod [Field R] [CharZero R] (g : α → M → ℚ) :
    (↑(f.prod g) : R) = f.prod fun a b => ↑(g a b) 
Arguments: {α : Type u_1} {M : Type u_5} {R : Type u_11} [Zero M] (f : α →₀ M) [Field R] [CharZero R] (g : α → M → ℚ)
Goal: ↑(f.prod g) = f.prod fun a b => ↑(g a b)
-- Finsupp.mapDomain_apply
theorem mapDomain_apply {f : α → β} (hf : Function.Injective f) (x : α →₀ M) (a : α) :
    mapDomain f x (f a) = x a 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] {f : α → β} (hf : Function.Injective f) (x : α →₀ M) (a : α)
Goal: (Finsupp.mapDomain f x) (f a) = x a