File: Mathlib/Algebra/Group/Hom/End.lean

full_name: AddMonoid.End.instAddMonoidWithOne
code: instance instAddMonoidWithOne (M) [AddCommMonoid M] : AddMonoidWithOne (AddMonoid.End M) 
goal: AddMonoidWithOne (AddMonoid.End M)

full_name: AddMonoid.End.natCast_apply
code: /-- See also `AddMonoid.End.natCast_def`. -/
@[simp]
lemma natCast_apply [AddCommMonoid M] (n : ℕ) (m : M) : (↑n : AddMonoid.End M) m = n • m 
goal: ↑n m = n • m

full_name: AddMonoid.End.ofNat_apply
code: @[simp] lemma ofNat_apply [AddCommMonoid M] (n : ℕ) [n.AtLeastTwo] (m : M) :
    (no_index (OfNat.ofNat n : AddMonoid.End M)) m = n • m 
goal: (OfNat.ofNat n) m = n • m

full_name: AddMonoid.End.instSemiring
code: instance instSemiring [AddCommMonoid M] : Semiring (AddMonoid.End M) 
goal: Semiring (AddMonoid.End M)

full_name: AddMonoid.End.instRing
code: instance instRing [AddCommGroup M] : Ring (AddMonoid.End M) 
goal: Ring (AddMonoid.End M)

full_name: AddMonoidHom.mul
code: /-- Multiplication of an element of a (semi)ring is an `AddMonoidHom` in both arguments.

This is a more-strongly bundled version of `AddMonoidHom.mulLeft` and `AddMonoidHom.mulRight`.

Stronger versions of this exists for algebras as `LinearMap.mul`, `NonUnitalAlgHom.mul`
and `Algebra.lmul`.
-/
def AddMonoidHom.mul : R →+ R →+ R 
goal: R →+ R →+ R

full_name: AddMonoidHom.mul_apply
code: theorem AddMonoidHom.mul_apply (x y : R) : AddMonoidHom.mul x y = x * y 
goal: (AddMonoidHom.mul x) y = x * y

full_name: AddMonoidHom.coe_mul
code: @[simp]
theorem AddMonoidHom.coe_mul : ⇑(AddMonoidHom.mul : R →+ R →+ R) = AddMonoidHom.mulLeft 
goal: ⇑AddMonoidHom.mul = AddMonoidHom.mulLeft

full_name: AddMonoidHom.coe_flip_mul
code: @[simp]
theorem AddMonoidHom.coe_flip_mul :
    ⇑(AddMonoidHom.mul : R →+ R →+ R).flip = AddMonoidHom.mulRight 
goal: ⇑AddMonoidHom.mul.flip = AddMonoidHom.mulRight

full_name: AddMonoidHom.map_mul_iff
code: /-- An `AddMonoidHom` preserves multiplication if pre- and post- composition with
`AddMonoidHom.mul` are equivalent. By converting the statement into an equality of
`AddMonoidHom`s, this lemma allows various specialized `ext` lemmas about `→+` to then be applied.
-/
theorem AddMonoidHom.map_mul_iff (f : R →+ S) :
    (∀ x y, f (x * y) = f x * f y) ↔
      (AddMonoidHom.mul : R →+ R →+ R).compr₂ f = (AddMonoidHom.mul.comp f).compl₂ f 
goal: (∀ (x y : R), f (x * y) = f x * f y) ↔ AddMonoidHom.mul.compr₂ f = (AddMonoidHom.mul.comp f).compl₂ f

full_name: AddMonoidHom.mulLeft_eq_mulRight_iff_forall_commute
code: lemma AddMonoidHom.mulLeft_eq_mulRight_iff_forall_commute {a : R} :
    mulLeft a = mulRight a ↔ ∀ b, Commute a b 
goal: AddMonoidHom.mulLeft a = AddMonoidHom.mulRight a ↔ ∀ (b : R), Commute a b

full_name: AddMonoidHom.mulRight_eq_mulLeft_iff_forall_commute
code: lemma AddMonoidHom.mulRight_eq_mulLeft_iff_forall_commute {b : R} :
    mulRight b = mulLeft b ↔ ∀ a, Commute a b 
goal: AddMonoidHom.mulRight b = AddMonoidHom.mulLeft b ↔ ∀ (a : R), Commute a b

full_name: AddMonoid.End.mulLeft
code: /-- The left multiplication map: `(a, b) ↦ a * b`. See also `AddMonoidHom.mulLeft`. -/
@[simps!]
def AddMonoid.End.mulLeft : R →+ AddMonoid.End R 
goal: R →+ AddMonoid.End R

full_name: AddMonoid.End.mulLeft_apply_apply
code: /-- The left multiplication map: `(a, b) ↦ a * b`. See also `AddMonoidHom.mulLeft`. -/
@[simps!]
def AddMonoid.End.mulLeft : R →+ AddMonoid.End R 
goal: ∀ (x : R), (AddMonoid.End.mulLeft r) x = r * x

full_name: AddMonoid.End.mulRight
code: /-- The right multiplication map: `(a, b) ↦ b * a`. See also `AddMonoidHom.mulRight`. -/
@[simps!]
def AddMonoid.End.mulRight : R →+ AddMonoid.End R 
goal: R →+ AddMonoid.End R

full_name: AddMonoid.End.mulRight_apply_apply
code: /-- The right multiplication map: `(a, b) ↦ b * a`. See also `AddMonoidHom.mulRight`. -/
@[simps!]
def AddMonoid.End.mulRight : R →+ AddMonoid.End R 
goal: (AddMonoid.End.mulRight y) x = x * y

full_name: AddMonoid.End.mulRight_eq_mulLeft
code: lemma mulRight_eq_mulLeft : mulRight = (mulLeft : R →+ AddMonoid.End R) 
goal: AddMonoid.End.mulRight = AddMonoid.End.mulLeft