ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- DirectSum.coeRingHom_of
@[simp]
theorem coeRingHom_of [AddMonoid ι] [SetLike.GradedMonoid A] (i : ι) (x : A i) :
    (coeRingHom A : _ →+* R) (of (fun i => A i) i x) = x 
Arguments: {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [DecidableEq ι] [Semiring R] [SetLike σ R] [AddSubmonoidClass σ R] (A : ι → σ) [AddMonoid ι] [SetLike.GradedMonoid A] (i : ι) (x : ↥(A i))
Goal: (DirectSum.coeRingHom A) ((DirectSum.of (fun i => ↥(A i)) i) x) = ↑x
-- DirectSum.coe_mul_apply
theorem coe_mul_apply [AddMonoid ι] [SetLike.GradedMonoid A]
    [∀ (i : ι) (x : A i), Decidable (x ≠ 0)] (r r' : ⨁ i, A i) (n : ι) :
    ((r * r') n : R) =
      ∑ ij ∈ (r.support ×ˢ r'.support).filter (fun ij : ι × ι => ij.1 + ij.2 = n),
        (r ij.1 * r' ij.2 : R) 
Arguments: {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [DecidableEq ι] [Semiring R] [SetLike σ R] [AddSubmonoidClass σ R] (A : ι → σ) [AddMonoid ι] [SetLike.GradedMonoid A] [(i : ι) → (x : ↥(A i)) → Decidable (x ≠ 0)] (r r' : ⨁ (i : ι), ↥(A i)) (n : ι)
Goal: ↑((r * r') n) =
  ∑ ij ∈ Finset.filter (fun ij => ij.1 + ij.2 = n) (DFinsupp.support r ×ˢ DFinsupp.support r'), ↑(r ij.1) * ↑(r' ij.2)
-- DirectSum.coe_mul_apply_eq_dfinsupp_sum
theorem coe_mul_apply_eq_dfinsupp_sum [AddMonoid ι] [SetLike.GradedMonoid A]
    [∀ (i : ι) (x : A i), Decidable (x ≠ 0)] (r r' : ⨁ i, A i) (n : ι) :
    ((r * r') n : R) = r.sum fun i ri => r'.sum fun j rj => if i + j = n then (ri * rj : R)
      else 0 
Arguments: {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [DecidableEq ι] [Semiring R] [SetLike σ R] [AddSubmonoidClass σ R] (A : ι → σ) [AddMonoid ι] [SetLike.GradedMonoid A] [(i : ι) → (x : ↥(A i)) → Decidable (x ≠ 0)] (r r' : ⨁ (i : ι), ↥(A i)) (n : ι)
Goal: ↑((r * r') n) = DFinsupp.sum r fun i ri => DFinsupp.sum r' fun j rj => if i + j = n then ↑ri * ↑rj else 0
-- DirectSum.coe_of_mul_apply_aux
theorem coe_of_mul_apply_aux [AddMonoid ι] [SetLike.GradedMonoid A] {i : ι} (r : A i)
    (r' : ⨁ i, A i) {j n : ι} (H : ∀ x : ι, i + x = n ↔ x = j) :
    ((of (fun i => A i) i r * r') n : R) = r * r' j 
Arguments: {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [DecidableEq ι] [Semiring R] [SetLike σ R] [AddSubmonoidClass σ R] (A : ι → σ) [AddMonoid ι] [SetLike.GradedMonoid A] {i : ι} (r : ↥(A i)) (r' : ⨁ (i : ι), ↥(A i)) {j n : ι} (H : ∀ (x : ι), i + x = n ↔ x = j)
Goal: ↑(((DirectSum.of (fun i => ↥(A i)) i) r * r') n) = ↑r * ↑(r' j)
-- DirectSum.coe_mul_of_apply_aux
theorem coe_mul_of_apply_aux [AddMonoid ι] [SetLike.GradedMonoid A] (r : ⨁ i, A i) {i : ι}
    (r' : A i) {j n : ι} (H : ∀ x : ι, x + i = n ↔ x = j) :
    ((r * of (fun i => A i) i r') n : R) = r j * r' 
Arguments: {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [DecidableEq ι] [Semiring R] [SetLike σ R] [AddSubmonoidClass σ R] (A : ι → σ) [AddMonoid ι] [SetLike.GradedMonoid A] (r : ⨁ (i : ι), ↥(A i)) {i : ι} (r' : ↥(A i)) {j n : ι} (H : ∀ (x : ι), x + i = n ↔ x = j)
Goal: ↑((r * (DirectSum.of (fun i => ↥(A i)) i) r') n) = ↑(r j) * ↑r'
-- DirectSum.coe_of_mul_apply_add
theorem coe_of_mul_apply_add [AddLeftCancelMonoid ι] [SetLike.GradedMonoid A] {i : ι} (r : A i)
    (r' : ⨁ i, A i) (j : ι) : ((of (fun i => A i) i r * r') (i + j) : R) = r * r' j 
Arguments: {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [DecidableEq ι] [Semiring R] [SetLike σ R] [AddSubmonoidClass σ R] (A : ι → σ) [AddLeftCancelMonoid ι] [SetLike.GradedMonoid A] {i : ι} (r : ↥(A i)) (r' : ⨁ (i : ι), ↥(A i)) (j : ι)
Goal: ↑(((DirectSum.of (fun i => ↥(A i)) i) r * r') (i + j)) = ↑r * ↑(r' j)
-- DirectSum.coe_mul_of_apply_add
theorem coe_mul_of_apply_add [AddRightCancelMonoid ι] [SetLike.GradedMonoid A] (r : ⨁ i, A i)
    {i : ι} (r' : A i) (j : ι) : ((r * of (fun i => A i) i r') (j + i) : R) = r j * r' 
Arguments: {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [DecidableEq ι] [Semiring R] [SetLike σ R] [AddSubmonoidClass σ R] (A : ι → σ) [AddRightCancelMonoid ι] [SetLike.GradedMonoid A] (r : ⨁ (i : ι), ↥(A i)) {i : ι} (r' : ↥(A i)) (j : ι)
Goal: ↑((r * (DirectSum.of (fun i => ↥(A i)) i) r') (j + i)) = ↑(r j) * ↑r'
-- DirectSum.coe_of_mul_apply_of_not_le
theorem coe_of_mul_apply_of_not_le {i : ι} (r : A i) (r' : ⨁ i, A i) (n : ι) (h : ¬i ≤ n) :
    ((of (fun i => A i) i r * r') n : R) = 0 
Arguments: {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [DecidableEq ι] [Semiring R] [SetLike σ R] [AddSubmonoidClass σ R] (A : ι → σ) [CanonicallyOrderedAddCommMonoid ι] [SetLike.GradedMonoid A] {i : ι} (r : ↥(A i)) (r' : ⨁ (i : ι), ↥(A i)) (n : ι) (h : ¬i ≤ n)
Goal: ↑(((DirectSum.of (fun i => ↥(A i)) i) r * r') n) = 0
-- DirectSum.coe_mul_of_apply_of_not_le
theorem coe_mul_of_apply_of_not_le (r : ⨁ i, A i) {i : ι} (r' : A i) (n : ι) (h : ¬i ≤ n) :
    ((r * of (fun i => A i) i r') n : R) = 0 
Arguments: {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [DecidableEq ι] [Semiring R] [SetLike σ R] [AddSubmonoidClass σ R] (A : ι → σ) [CanonicallyOrderedAddCommMonoid ι] [SetLike.GradedMonoid A] (r : ⨁ (i : ι), ↥(A i)) {i : ι} (r' : ↥(A i)) (n : ι) (h : ¬i ≤ n)
Goal: ↑((r * (DirectSum.of (fun i => ↥(A i)) i) r') n) = 0
-- DirectSum.coe_mul_of_apply_of_le
theorem coe_mul_of_apply_of_le (r : ⨁ i, A i) {i : ι} (r' : A i) (n : ι) (h : i ≤ n) :
    ((r * of (fun i => A i) i r') n : R) = r (n - i) * r' 
Arguments: {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [DecidableEq ι] [Semiring R] [SetLike σ R] [AddSubmonoidClass σ R] (A : ι → σ) [CanonicallyOrderedAddCommMonoid ι] [SetLike.GradedMonoid A] [Sub ι] [OrderedSub ι] [ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (r : ⨁ (i : ι), ↥(A i)) {i : ι} (r' : ↥(A i)) (n : ι) (h : i ≤ n)
Goal: ↑((r * (DirectSum.of (fun i => ↥(A i)) i) r') n) = ↑(r (n - i)) * ↑r'
-- DirectSum.coe_of_mul_apply_of_le
theorem coe_of_mul_apply_of_le {i : ι} (r : A i) (r' : ⨁ i, A i) (n : ι) (h : i ≤ n) :
    ((of (fun i => A i) i r * r') n : R) = r * r' (n - i) 
Arguments: {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [DecidableEq ι] [Semiring R] [SetLike σ R] [AddSubmonoidClass σ R] (A : ι → σ) [CanonicallyOrderedAddCommMonoid ι] [SetLike.GradedMonoid A] [Sub ι] [OrderedSub ι] [ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {i : ι} (r : ↥(A i)) (r' : ⨁ (i : ι), ↥(A i)) (n : ι) (h : i ≤ n)
Goal: ↑(((DirectSum.of (fun i => ↥(A i)) i) r * r') n) = ↑r * ↑(r' (n - i))
-- DirectSum.coe_mul_of_apply
theorem coe_mul_of_apply (r : ⨁ i, A i) {i : ι} (r' : A i) (n : ι) [Decidable (i ≤ n)] :
    ((r * of (fun i => A i) i r') n : R) = if i ≤ n then (r (n - i) : R) * r' else 0 
Arguments: {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [DecidableEq ι] [Semiring R] [SetLike σ R] [AddSubmonoidClass σ R] (A : ι → σ) [CanonicallyOrderedAddCommMonoid ι] [SetLike.GradedMonoid A] [Sub ι] [OrderedSub ι] [ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (r : ⨁ (i : ι), ↥(A i)) {i : ι} (r' : ↥(A i)) (n : ι) [Decidable (i ≤ n)]
Goal: ↑((r * (DirectSum.of (fun i => ↥(A i)) i) r') n) = if i ≤ n then ↑(r (n - i)) * ↑r' else 0
-- DirectSum.coe_of_mul_apply
theorem coe_of_mul_apply {i : ι} (r : A i) (r' : ⨁ i, A i) (n : ι) [Decidable (i ≤ n)] :
    ((of (fun i => A i) i r * r') n : R) = if i ≤ n then (r * r' (n - i) : R) else 0 
Arguments: {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [DecidableEq ι] [Semiring R] [SetLike σ R] [AddSubmonoidClass σ R] (A : ι → σ) [CanonicallyOrderedAddCommMonoid ι] [SetLike.GradedMonoid A] [Sub ι] [OrderedSub ι] [ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {i : ι} (r : ↥(A i)) (r' : ⨁ (i : ι), ↥(A i)) (n : ι) [Decidable (i ≤ n)]
Goal: ↑(((DirectSum.of (fun i => ↥(A i)) i) r * r') n) = if i ≤ n then ↑r * ↑(r' (n - i)) else 0
-- Submodule.setLike.coe_galgebra_toFun
@[simp]
theorem setLike.coe_galgebra_toFun [AddMonoid ι] [CommSemiring S] [Semiring R] [Algebra S R]
    (A : ι → Submodule S R) [SetLike.GradedMonoid A] (s : S) :
    ↑(@DirectSum.GAlgebra.toFun _ S (fun i => A i) _ _ _ _ _ _ _ s) = (algebraMap S R s : R) 
Arguments: {ι : Type u_1} {S : Type u_3} {R : Type u_4} [DecidableEq ι] [AddMonoid ι] [CommSemiring S] [Semiring R] [Algebra S R] (A : ι → Submodule S R) [SetLike.GradedMonoid A] (s : S)
Goal: ↑(DirectSum.GAlgebra.toFun s) = (algebraMap S R) s
-- Submodule.iSup_eq_toSubmodule_range
theorem Submodule.iSup_eq_toSubmodule_range [AddMonoid ι] [CommSemiring S] [Semiring R]
    [Algebra S R] (A : ι → Submodule S R) [SetLike.GradedMonoid A] :
    ⨆ i, A i = Subalgebra.toSubmodule (DirectSum.coeAlgHom A).range 
Arguments: {ι : Type u_1} {S : Type u_3} {R : Type u_4} [DecidableEq ι] [AddMonoid ι] [CommSemiring S] [Semiring R] [Algebra S R] (A : ι → Submodule S R) [SetLike.GradedMonoid A]
Goal: ⨆ i, A i = Subalgebra.toSubmodule (DirectSum.coeAlgHom A).range
-- DirectSum.coeAlgHom_of
@[simp]
theorem DirectSum.coeAlgHom_of [AddMonoid ι] [CommSemiring S] [Semiring R] [Algebra S R]
    (A : ι → Submodule S R) [SetLike.GradedMonoid A] (i : ι) (x : A i) :
    DirectSum.coeAlgHom A (DirectSum.of (fun i => A i) i x) = x 
Arguments: {ι : Type u_1} {S : Type u_3} {R : Type u_4} [DecidableEq ι] [AddMonoid ι] [CommSemiring S] [Semiring R] [Algebra S R] (A : ι → Submodule S R) [SetLike.GradedMonoid A] (i : ι) (x : ↥(A i))
Goal: (DirectSum.coeAlgHom A) ((DirectSum.of (fun i => ↥(A i)) i) x) = ↑x
-- SetLike.GradeZero.coe_natCast
@[nolint simpNF, simp, norm_cast] theorem coe_natCast (n : ℕ) : (n : A 0) = (n : R) 
Arguments: {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [Semiring R] [AddMonoid ι] [SetLike σ R] [AddSubmonoidClass σ R] (A : ι → σ) [SetLike.GradedMonoid A] (n : ℕ)
Goal: ↑↑n = ↑n
-- SetLike.GradeZero.coe_ofNat
@[nolint simpNF, simp, norm_cast] theorem coe_ofNat (n : ℕ) [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n) : A 0) = (OfNat.ofNat n : R) 
Arguments: {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [Semiring R] [AddMonoid ι] [SetLike σ R] [AddSubmonoidClass σ R] (A : ι → σ) [SetLike.GradedMonoid A] (n : ℕ) [n.AtLeastTwo]
Goal: ↑(OfNat.ofNat n) = OfNat.ofNat n
-- SetLike.GradeZero.coe_intCast
theorem coe_intCast (z : ℤ) : (z : A 0) = (z : R) 
Arguments: {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [Ring R] [AddMonoid ι] [SetLike σ R] [AddSubgroupClass σ R] (A : ι → σ) [SetLike.GradedMonoid A] (z : ℤ)
Goal: ↑↑z = ↑z
-- SetLike.GradeZero.coe_algebraMap
@[nolint simpNF, simp, norm_cast] theorem coe_algebraMap (s : S) :
    ↑(algebraMap _ (A 0) s) = algebraMap _ R s 
Arguments: {ι : Type u_1} {S : Type u_3} {R : Type u_4} [CommSemiring S] [Semiring R] [Algebra S R] [AddMonoid ι] (A : ι → Submodule S R) [SetLike.GradedMonoid A] (s : S)
Goal: ↑((algebraMap S ↥(A 0)) s) = (algebraMap S R) s
-- SetLike.homogeneous_zero_submodule
theorem SetLike.homogeneous_zero_submodule [Zero ι] [Semiring S] [AddCommMonoid R] [Module S R]
    (A : ι → Submodule S R) : SetLike.Homogeneous A (0 : R) 
Arguments: {ι : Type u_1} {S : Type u_3} {R : Type u_4} [Zero ι] [Semiring S] [AddCommMonoid R] [Module S R] (A : ι → Submodule S R)
Goal: SetLike.Homogeneous A 0
-- SetLike.Homogeneous.smul
theorem SetLike.Homogeneous.smul [CommSemiring S] [Semiring R] [Algebra S R] {A : ι → Submodule S R}
    {s : S} {r : R} (hr : SetLike.Homogeneous A r) : SetLike.Homogeneous A (s • r) 
Arguments: {ι : Type u_1} {S : Type u_3} {R : Type u_4} [CommSemiring S] [Semiring R] [Algebra S R] {A : ι → Submodule S R} {s : S} {r : R} (hr : SetLike.Homogeneous A r)
Goal: SetLike.Homogeneous A (s • r)
-- AddMonoid.End.zero_apply
@[simp]
theorem AddMonoid.End.zero_apply [AddCommMonoid M] (m : M) : (0 : AddMonoid.End M) m = 0 
Arguments: {M : Type uM} [AddCommMonoid M] (m : M)
Goal: 0 m = 0
-- AddMonoid.End.one_apply
theorem AddMonoid.End.one_apply [AddCommMonoid M] (m : M) : (1 : AddMonoid.End M) m = m 
Arguments: {M : Type uM} [AddCommMonoid M] (m : M)
Goal: 1 m = m
-- AddMonoid.End.intCast_apply
@[simp]
theorem AddMonoid.End.intCast_apply [AddCommGroup M] (z : ℤ) (m : M) :
    (↑z : AddMonoid.End M) m = z • m 
Arguments: {M : Type uM} [AddCommGroup M] (z : ℤ) (m : M)
Goal: ↑z m = z • m
-- AddMonoidHom.nsmul_apply
@[to_additive (attr := simp)] lemma MonoidHom.pow_apply {M N : Type*} [MulOneClass M]
    [CommMonoid N] (f : M →* N) (n : ℕ) (x : M) :
    (f ^ n) x = (f x) ^ n 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddCommMonoid N] (f : M →+ N) (n : ℕ) (x : M)
Goal: (n • f) x = n • f x
-- MonoidHom.pow_apply
@[to_additive (attr := simp)] lemma MonoidHom.pow_apply {M N : Type*} [MulOneClass M]
    [CommMonoid N] (f : M →* N) (n : ℕ) (x : M) :
    (f ^ n) x = (f x) ^ n 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [CommMonoid N] (f : M →* N) (n : ℕ) (x : M)
Goal: (f ^ n) x = f x ^ n
-- AddMonoidHom.ext_iff₂
@[to_additive]
theorem ext_iff₂ {_ : MulOneClass M} {_ : MulOneClass N} {_ : CommMonoid P} {f g : M →* N →* P} :
    f = g ↔ ∀ x y, f x y = g x y 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP}
Goal: ∀ {x : AddZeroClass M} {x_1 : AddZeroClass N} {x_2 : AddCommMonoid P} {f g : M →+ N →+ P},
  f = g ↔ ∀ (x_3 : M) (y : N), (f x_3) y = (g x_3) y
-- MonoidHom.ext_iff₂
@[to_additive]
theorem ext_iff₂ {_ : MulOneClass M} {_ : MulOneClass N} {_ : CommMonoid P} {f g : M →* N →* P} :
    f = g ↔ ∀ x y, f x y = g x y 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP}
Goal: ∀ {x : MulOneClass M} {x_1 : MulOneClass N} {x_2 : CommMonoid P} {f g : M →* N →* P},
  f = g ↔ ∀ (x_3 : M) (y : N), (f x_3) y = (g x_3) y
-- MonoidHom.flip_apply
@[to_additive (attr := simp)]
theorem flip_apply {_ : MulOneClass M} {_ : MulOneClass N} {_ : CommMonoid P} (f : M →* N →* P)
    (x : M) (y : N) : f.flip y x = f x y 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP}
Goal: ∀ {x : MulOneClass M} {x_1 : MulOneClass N} {x_2 : CommMonoid P} (f : M →* N →* P) (x_3 : M) (y : N),
  (f.flip y) x_3 = (f x_3) y
-- AddMonoidHom.flip_apply
@[to_additive (attr := simp)]
theorem flip_apply {_ : MulOneClass M} {_ : MulOneClass N} {_ : CommMonoid P} (f : M →* N →* P)
    (x : M) (y : N) : f.flip y x = f x y 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP}
Goal: ∀ {x : AddZeroClass M} {x_1 : AddZeroClass N} {x_2 : AddCommMonoid P} (f : M →+ N →+ P) (x_3 : M) (y : N),
  (f.flip y) x_3 = (f x_3) y
-- AddMonoidHom.map_one₂
@[to_additive]
theorem map_one₂ {_ : MulOneClass M} {_ : MulOneClass N} {_ : CommMonoid P} (f : M →* N →* P)
    (n : N) : f 1 n = 1 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP}
Goal: ∀ {x : AddZeroClass M} {x_1 : AddZeroClass N} {x_2 : AddCommMonoid P} (f : M →+ N →+ P) (n : N), (f 0) n = 0
-- MonoidHom.map_one₂
@[to_additive]
theorem map_one₂ {_ : MulOneClass M} {_ : MulOneClass N} {_ : CommMonoid P} (f : M →* N →* P)
    (n : N) : f 1 n = 1 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP}
Goal: ∀ {x : MulOneClass M} {x_1 : MulOneClass N} {x_2 : CommMonoid P} (f : M →* N →* P) (n : N), (f 1) n = 1
-- MonoidHom.map_mul₂
@[to_additive]
theorem map_mul₂ {_ : MulOneClass M} {_ : MulOneClass N} {_ : CommMonoid P} (f : M →* N →* P)
    (m₁ m₂ : M) (n : N) : f (m₁ * m₂) n = f m₁ n * f m₂ n 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP}
Goal: ∀ {x : MulOneClass M} {x_1 : MulOneClass N} {x_2 : CommMonoid P} (f : M →* N →* P) (m₁ m₂ : M) (n : N),
  (f (m₁ * m₂)) n = (f m₁) n * (f m₂) n
-- AddMonoidHom.map_mul₂
@[to_additive]
theorem map_mul₂ {_ : MulOneClass M} {_ : MulOneClass N} {_ : CommMonoid P} (f : M →* N →* P)
    (m₁ m₂ : M) (n : N) : f (m₁ * m₂) n = f m₁ n * f m₂ n 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP}
Goal: ∀ {x : AddZeroClass M} {x_1 : AddZeroClass N} {x_2 : AddCommMonoid P} (f : M →+ N →+ P) (m₁ m₂ : M) (n : N),
  (f (m₁ + m₂)) n = (f m₁) n + (f m₂) n
-- MonoidHom.map_inv₂
@[to_additive]
theorem map_inv₂ {_ : Group M} {_ : MulOneClass N} {_ : CommGroup P} (f : M →* N →* P) (m : M)
    (n : N) : f m⁻¹ n = (f m n)⁻¹ 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP}
Goal: ∀ {x : Group M} {x_1 : MulOneClass N} {x_2 : CommGroup P} (f : M →* N →* P) (m : M) (n : N), (f m⁻¹) n = ((f m) n)⁻¹
-- AddMonoidHom.map_inv₂
@[to_additive]
theorem map_inv₂ {_ : Group M} {_ : MulOneClass N} {_ : CommGroup P} (f : M →* N →* P) (m : M)
    (n : N) : f m⁻¹ n = (f m n)⁻¹ 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP}
Goal: ∀ {x : AddGroup M} {x_1 : AddZeroClass N} {x_2 : AddCommGroup P} (f : M →+ N →+ P) (m : M) (n : N),
  (f (-m)) n = -(f m) n
-- AddMonoidHom.map_div₂
@[to_additive]
theorem map_div₂ {_ : Group M} {_ : MulOneClass N} {_ : CommGroup P} (f : M →* N →* P)
    (m₁ m₂ : M) (n : N) : f (m₁ / m₂) n = f m₁ n / f m₂ n 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP}
Goal: ∀ {x : AddGroup M} {x_1 : AddZeroClass N} {x_2 : AddCommGroup P} (f : M →+ N →+ P) (m₁ m₂ : M) (n : N),
  (f (m₁ - m₂)) n = (f m₁) n - (f m₂) n
-- MonoidHom.map_div₂
@[to_additive]
theorem map_div₂ {_ : Group M} {_ : MulOneClass N} {_ : CommGroup P} (f : M →* N →* P)
    (m₁ m₂ : M) (n : N) : f (m₁ / m₂) n = f m₁ n / f m₂ n 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP}
Goal: ∀ {x : Group M} {x_1 : MulOneClass N} {x_2 : CommGroup P} (f : M →* N →* P) (m₁ m₂ : M) (n : N),
  (f (m₁ / m₂)) n = (f m₁) n / (f m₂) n
-- MonoidHom.eval_apply_apply
@[to_additive (attr := simps!)
      "Evaluation of an `AddMonoidHom` at a point as an additive monoid homomorphism.
      See also `AddMonoidHom.apply` for the evaluation of any function at a point."]
def eval [MulOneClass M] [CommMonoid N] : M →* (M →* N) →* N 
Arguments: {M : Type uM} {N : Type uN} [MulOneClass M] [CommMonoid N] (y : M) (x : M →* N)
Goal: (MonoidHom.eval y) x = x y
-- AddMonoidHom.eval_apply_apply
@[to_additive (attr := simps!)
      "Evaluation of an `AddMonoidHom` at a point as an additive monoid homomorphism.
      See also `AddMonoidHom.apply` for the evaluation of any function at a point."]
def eval [MulOneClass M] [CommMonoid N] : M →* (M →* N) →* N 
Arguments: {M : Type uM} {N : Type uN} [AddZeroClass M] [AddCommMonoid N] (y : M) (x : M →+ N)
Goal: (AddMonoidHom.eval y) x = x y
-- MonoidHom.compHom'_apply_apply
@[to_additive (attr := simps!)
      "The expression `fun g m ↦ g (f m)` as an `AddMonoidHom`.
      Equivalently, `(fun g ↦ AddMonoidHom.comp g f)` as an `AddMonoidHom`.

      This also exists in a `LinearMap` version, `LinearMap.lcomp`."]
def compHom' [MulOneClass M] [MulOneClass N] [CommMonoid P] (f : M →* N) : (N →* P) →* M →* P 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP} [MulOneClass M] [MulOneClass N] [CommMonoid P] (f : M →* N) (y : N →* P) (x : M)
Goal: (f.compHom' y) x = y (f x)
-- AddMonoidHom.compHom'_apply_apply
@[to_additive (attr := simps!)
      "The expression `fun g m ↦ g (f m)` as an `AddMonoidHom`.
      Equivalently, `(fun g ↦ AddMonoidHom.comp g f)` as an `AddMonoidHom`.

      This also exists in a `LinearMap` version, `LinearMap.lcomp`."]
def compHom' [MulOneClass M] [MulOneClass N] [CommMonoid P] (f : M →* N) : (N →* P) →* M →* P 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP} [AddZeroClass M] [AddZeroClass N] [AddCommMonoid P] (f : M →+ N) (y : N →+ P) (x : M)
Goal: (f.compHom' y) x = y (f x)
-- AddMonoidHom.compHom_apply_apply
@[to_additive (attr := simps)
      "Composition of additive monoid morphisms (`AddMonoidHom.comp`) as an additive
      monoid morphism.

      Note that unlike `AddMonoidHom.comp_hom'` this requires commutativity of `N`.

      This also exists in a `LinearMap` version, `LinearMap.llcomp`."]
def compHom [MulOneClass M] [CommMonoid N] [CommMonoid P] :
    (N →* P) →* (M →* N) →* M →* P 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP} [AddZeroClass M] [AddCommMonoid N] [AddCommMonoid P] (g : N →+ P) (hmn : M →+ N)
Goal: (AddMonoidHom.compHom g) hmn = g.comp hmn
-- MonoidHom.compHom_apply_apply
@[to_additive (attr := simps)
      "Composition of additive monoid morphisms (`AddMonoidHom.comp`) as an additive
      monoid morphism.

      Note that unlike `AddMonoidHom.comp_hom'` this requires commutativity of `N`.

      This also exists in a `LinearMap` version, `LinearMap.llcomp`."]
def compHom [MulOneClass M] [CommMonoid N] [CommMonoid P] :
    (N →* P) →* (M →* N) →* M →* P 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP} [MulOneClass M] [CommMonoid N] [CommMonoid P] (g : N →* P) (hmn : M →* N)
Goal: (MonoidHom.compHom g) hmn = g.comp hmn
-- MonoidHom.flipHom_apply
@[to_additive (attr := simps)
      "Flipping arguments of additive monoid morphisms (`AddMonoidHom.flip`)
      as an additive monoid morphism."]
def flipHom {_ : MulOneClass M} {_ : MulOneClass N} {_ : CommMonoid P} :
    (M →* N →* P) →* N →* M →* P 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP}
Goal: ∀ {x : MulOneClass M} {x_1 : MulOneClass N} {x_2 : CommMonoid P} (f : M →* N →* P), MonoidHom.flipHom f = f.flip
-- AddMonoidHom.flipHom_apply
@[to_additive (attr := simps)
      "Flipping arguments of additive monoid morphisms (`AddMonoidHom.flip`)
      as an additive monoid morphism."]
def flipHom {_ : MulOneClass M} {_ : MulOneClass N} {_ : CommMonoid P} :
    (M →* N →* P) →* N →* M →* P 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP}
Goal: ∀ {x : AddZeroClass M} {x_1 : AddZeroClass N} {x_2 : AddCommMonoid P} (f : M →+ N →+ P), AddMonoidHom.flipHom f = f.flip
-- AddMonoidHom.compl₂_apply
@[to_additive (attr := simp)]
theorem compl₂_apply [MulOneClass M] [MulOneClass N] [CommMonoid P] [MulOneClass Q]
    (f : M →* N →* P) (g : Q →* N) (m : M) (q : Q) : (compl₂ f g) m q = f m (g q) 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [AddZeroClass M] [AddZeroClass N] [AddCommMonoid P] [AddZeroClass Q] (f : M →+ N →+ P) (g : Q →+ N) (m : M) (q : Q)
Goal: ((f.compl₂ g) m) q = (f m) (g q)
-- MonoidHom.compl₂_apply
@[to_additive (attr := simp)]
theorem compl₂_apply [MulOneClass M] [MulOneClass N] [CommMonoid P] [MulOneClass Q]
    (f : M →* N →* P) (g : Q →* N) (m : M) (q : Q) : (compl₂ f g) m q = f m (g q) 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [MulOneClass M] [MulOneClass N] [CommMonoid P] [MulOneClass Q] (f : M →* N →* P) (g : Q →* N) (m : M) (q : Q)
Goal: ((f.compl₂ g) m) q = (f m) (g q)
-- AddMonoidHom.compr₂_apply
@[to_additive (attr := simp)]
theorem compr₂_apply [MulOneClass M] [MulOneClass N] [CommMonoid P] [CommMonoid Q] (f : M →* N →* P)
    (g : P →* Q) (m : M) (n : N) : (compr₂ f g) m n = g (f m n) 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [AddZeroClass M] [AddZeroClass N] [AddCommMonoid P] [AddCommMonoid Q] (f : M →+ N →+ P) (g : P →+ Q) (m : M) (n : N)
Goal: ((f.compr₂ g) m) n = g ((f m) n)
-- MonoidHom.compr₂_apply
@[to_additive (attr := simp)]
theorem compr₂_apply [MulOneClass M] [MulOneClass N] [CommMonoid P] [CommMonoid Q] (f : M →* N →* P)
    (g : P →* Q) (m : M) (n : N) : (compr₂ f g) m n = g (f m n) 
Arguments: {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [MulOneClass M] [MulOneClass N] [CommMonoid P] [CommMonoid Q] (f : M →* N →* P) (g : P →* Q) (m : M) (n : N)
Goal: ((f.compr₂ g) m) n = g ((f m) n)
-- Subsemigroup.toAddSubsemigroup_apply_coe
@[simps]
def Subsemigroup.toAddSubsemigroup : Subsemigroup M ≃o AddSubsemigroup (Additive M) 
Arguments: {M : Type u_1} [Mul M] (S : Subsemigroup M)
Goal: ↑(Subsemigroup.toAddSubsemigroup S) = ⇑Additive.toMul ⁻¹' ↑S
-- Subsemigroup.toAddSubsemigroup_symm_apply_coe
@[simps]
def Subsemigroup.toAddSubsemigroup : Subsemigroup M ≃o AddSubsemigroup (Additive M) 
Arguments: {M : Type u_1} [Mul M] (S : AddSubsemigroup (Additive M))
Goal: ↑((RelIso.symm Subsemigroup.toAddSubsemigroup) S) = ⇑Additive.ofMul ⁻¹' ↑S
-- Subsemigroup.toAddSubsemigroup_closure
theorem Subsemigroup.toAddSubsemigroup_closure (S : Set M) :
    Subsemigroup.toAddSubsemigroup (Subsemigroup.closure S) =
    AddSubsemigroup.closure (Additive.toMul ⁻¹' S) 
Arguments: {M : Type u_1} [Mul M] (S : Set M)
Goal: Subsemigroup.toAddSubsemigroup (Subsemigroup.closure S) = AddSubsemigroup.closure (⇑Additive.toMul ⁻¹' S)
-- AddSubsemigroup.toSubsemigroup'_closure
theorem AddSubsemigroup.toSubsemigroup'_closure (S : Set (Additive M)) :
    AddSubsemigroup.toSubsemigroup' (AddSubsemigroup.closure S) =
      Subsemigroup.closure (Additive.ofMul ⁻¹' S) 
Arguments: {M : Type u_1} [Mul M] (S : Set (Additive M))
Goal: AddSubsemigroup.toSubsemigroup' (AddSubsemigroup.closure S) = Subsemigroup.closure (⇑Additive.ofMul ⁻¹' S)
-- AddSubsemigroup.toSubsemigroup_apply_coe
@[simps]
def AddSubsemigroup.toSubsemigroup : AddSubsemigroup A ≃o Subsemigroup (Multiplicative A) 
Arguments: {A : Type u_5} [Add A] (S : AddSubsemigroup A)
Goal: ↑(AddSubsemigroup.toSubsemigroup S) = ⇑Multiplicative.toAdd ⁻¹' ↑S