# Documentation

Mathlib.Algebra.Hom.GroupInstances

# Instances on spaces of monoid and group morphisms #

We endow the space of monoid morphisms M →* N→* N with a CommMonoid structure when the target is commutative, through pointwise multiplication, and with a CommGroup structure when the target is a commutative group. We also prove the same instances for additive situations.

Since these structures permit morphisms of morphisms, we also provide some composition-like operations.

Finally, we provide the Ring structure on AddMonoid.End.

def AddMonoidHom.addCommMonoid.proof_6 {M : Type u_1} {N : Type u_2} [inst : ] [inst : ] (f : M →+ N) :
(fun n f => { toZeroHom := { toFun := fun x => n f x, map_zero' := (_ : n f 0 = 0) }, map_add' := (_ : ∀ (x y : M), n f (x + y) = n f x + n f y) }) 0 f = 0
Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.addCommMonoid.proof_8 {M : Type u_1} {N : Type u_2} [inst : ] [inst : ] :
∀ (a b : M →+ N), a + b = b + a
Equations
• (_ : a + b = b + a) = (_ : a + b = b + a)
def AddMonoidHom.addCommMonoid.proof_4 {M : Type u_2} {N : Type u_1} [inst : ] [inst : ] (n : ) (f : M →+ N) :
n f 0 = 0
Equations
• (_ : n f 0 = 0) = (_ : n f 0 = 0)
def AddMonoidHom.addCommMonoid.proof_5 {M : Type u_2} {N : Type u_1} [inst : ] [inst : ] (n : ) (f : M →+ N) (x : M) (y : M) :
n f (x + y) = n f x + n f y
Equations
instance AddMonoidHom.addCommMonoid {M : Type uM} {N : Type uN} [inst : ] [inst : ] :

(M →+ N)→+ N) is an AddCommMonoid if N is commutative.

Equations
def AddMonoidHom.addCommMonoid.proof_7 {M : Type u_1} {N : Type u_2} [inst : ] [inst : ] (n : ) (f : M →+ N) :
(fun n f => { toZeroHom := { toFun := fun x => n f x, map_zero' := (_ : n f 0 = 0) }, map_add' := (_ : ∀ (x y : M), n f (x + y) = n f x + n f y) }) (n + 1) f = f + (fun n f => { toZeroHom := { toFun := fun x => n f x, map_zero' := (_ : n f 0 = 0) }, map_add' := (_ : ∀ (x y : M), n f (x + y) = n f x + n f y) }) n f
Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.addCommMonoid.proof_2 {M : Type u_1} {N : Type u_2} [inst : ] [inst : ] :
∀ (a : M →+ N), 0 + a = a
Equations
• (_ : 0 + a = a) = (_ : 0 + a = a)
def AddMonoidHom.addCommMonoid.proof_1 {M : Type u_1} {N : Type u_2} [inst : ] [inst : ] :
∀ (a b c : M →+ N), a + b + c = a + (b + c)
Equations
• (_ : a + b + c = a + (b + c)) = (_ : a + b + c = a + (b + c))
def AddMonoidHom.addCommMonoid.proof_3 {M : Type u_1} {N : Type u_2} [inst : ] [inst : ] :
∀ (a : M →+ N), a + 0 = a
Equations
• (_ : a + 0 = a) = (_ : a + 0 = a)
instance MonoidHom.commMonoid {M : Type uM} {N : Type uN} [inst : ] [inst : ] :

(M →* N)→* N) is a CommMonoid if N is commutative.

Equations
instance AddMonoidHom.addCommGroup {M : Type u_1} {G : Type u_2} [inst : ] [inst : ] :

If G is an additive commutative group, then M →+ G→+ G is an additive commutative group too.

Equations
• AddMonoidHom.addCommGroup = let src := AddMonoidHom.addCommMonoid; AddCommGroup.mk (_ : ∀ (a b : M →+ G), a + b = b + a)
def AddMonoidHom.addCommGroup.proof_8 {M : Type u_1} {G : Type u_2} [inst : ] [inst : ] (a : M →+ G) (b : M →+ G) :
a + b = b + a
Equations
• (_ : ∀ (a b : M →+ G), a + b = b + a) = (_ : ∀ (a b : M →+ G), a + b = b + a)
def AddMonoidHom.addCommGroup.proof_1 {M : Type u_1} {G : Type u_2} [inst : ] [inst : ] :
∀ (a b : M →+ G), a - b = a + -b
Equations
def AddMonoidHom.addCommGroup.proof_2 {M : Type u_2} {G : Type u_1} [inst : ] [inst : ] (n : ) (f : M →+ G) :
n f 0 = 0
Equations
• (_ : n f 0 = 0) = (_ : n f 0 = 0)
def AddMonoidHom.addCommGroup.proof_7 {M : Type u_1} {G : Type u_2} [inst : ] [inst : ] :
∀ (a : M →+ G), -a + a = 0
Equations
• (_ : -a + a = 0) = (_ : -a + a = 0)
def AddMonoidHom.addCommGroup.proof_5 {M : Type u_1} {G : Type u_2} [inst : ] [inst : ] (n : ) (f : M →+ G) :
(fun n f => { toZeroHom := { toFun := fun x => n f x, map_zero' := (_ : n f 0 = 0) }, map_add' := (_ : ∀ (x y : M), n f (x + y) = n f x + n f y) }) () f = f + (fun n f => { toZeroHom := { toFun := fun x => n f x, map_zero' := (_ : n f 0 = 0) }, map_add' := (_ : ∀ (x y : M), n f (x + y) = n f x + n f y) }) () f
Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.addCommGroup.proof_4 {M : Type u_1} {G : Type u_2} [inst : ] [inst : ] (f : M →+ G) :
(fun n f => { toZeroHom := { toFun := fun x => n f x, map_zero' := (_ : n f 0 = 0) }, map_add' := (_ : ∀ (x y : M), n f (x + y) = n f x + n f y) }) 0 f = 0
Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.addCommGroup.proof_3 {M : Type u_2} {G : Type u_1} [inst : ] [inst : ] (n : ) (f : M →+ G) (x : M) (y : M) :
n f (x + y) = n f x + n f y
Equations
def AddMonoidHom.addCommGroup.proof_6 {M : Type u_1} {G : Type u_2} [inst : ] [inst : ] (n : ) (f : M →+ G) :
(fun n f => { toZeroHom := { toFun := fun x => n f x, map_zero' := (_ : n f 0 = 0) }, map_add' := (_ : ∀ (x y : M), n f (x + y) = n f x + n f y) }) () f = -(fun n f => { toZeroHom := { toFun := fun x => n f x, map_zero' := (_ : n f 0 = 0) }, map_add' := (_ : ∀ (x y : M), n f (x + y) = n f x + n f y) }) (↑()) f
Equations
• One or more equations did not get rendered due to their size.
instance MonoidHom.commGroup {M : Type u_1} {G : Type u_2} [inst : ] [inst : ] :

If G is a commutative group, then M →* G→* G is a commutative group too.

Equations
• MonoidHom.commGroup = let src := MonoidHom.commMonoid; CommGroup.mk (_ : ∀ (a b : M →* G), a * b = b * a)
Equations
instance AddMonoid.End.semiring {M : Type uM} [inst : ] :
Equations
• One or more equations did not get rendered due to their size.
@[simp]
theorem AddMonoid.End.natCast_apply {M : Type uM} [inst : ] (n : ) (m : M) :
n m = n m

See also AddMonoid.End.natCast_def.

Equations
Equations
• One or more equations did not get rendered due to their size.
@[simp]
theorem AddMonoid.End.int_cast_apply {M : Type uM} [inst : ] (z : ) (m : M) :
z m = z m

See also AddMonoid.End.intCast_def.

### Morphisms of morphisms #

The structures above permit morphisms that themselves produce morphisms, provided the codomain is commutative.

theorem AddMonoidHom.ext_iff₂ {M : Type uM} {N : Type uN} {P : Type uP} :
∀ {x : } {x_1 : } {x_2 : } {f g : M →+ N →+ P}, f = g ∀ (x_3 : M) (y : N), ↑(f x_3) y = ↑(g x_3) y
theorem MonoidHom.ext_iff₂ {M : Type uM} {N : Type uN} {P : Type uP} :
∀ {x : } {x_1 : } {x_2 : } {f g : M →* N →* P}, f = g ∀ (x_3 : M) (y : N), ↑(f x_3) y = ↑(g x_3) y
def AddMonoidHom.flip.proof_2 {M : Type u_3} {N : Type u_2} {P : Type u_1} {mM : } {mN : } {mP : } (f : M →+ N →+ P) (y : N) (x₁ : M) (x₂ : M) :
↑(f (x₁ + x₂)) y = ↑(f x₁) y + ↑(f x₂) y
Equations
• (_ : ↑(f (x₁ + x₂)) y = ↑(f x₁) y + ↑(f x₂) y) = (_ : ↑(f (x₁ + x₂)) y = ↑(f x₁) y + ↑(f x₂) y)
def AddMonoidHom.flip {M : Type uM} {N : Type uN} {P : Type uP} {mM : } {mN : } {mP : } (f : M →+ N →+ P) :
N →+ M →+ P

flip arguments of f : M →+ N →+ P→+ N →+ P→+ P

Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.flip.proof_1 {M : Type u_3} {N : Type u_2} {P : Type u_1} {mM : } {mN : } {mP : } (f : M →+ N →+ P) (y : N) :
↑(f 0) y = 0
Equations
• (_ : ↑(f 0) y = 0) = (_ : ↑(f 0) y = 0)
def AddMonoidHom.flip.proof_4 {M : Type u_1} {N : Type u_3} {P : Type u_2} {mM : } {mN : } {mP : } (f : M →+ N →+ P) (y₁ : N) (y₂ : N) :
ZeroHom.toFun { toFun := fun y => { toZeroHom := { toFun := fun x => ↑(f x) y, map_zero' := (_ : ↑(f 0) y = 0) }, map_add' := (_ : ∀ (x₁ x₂ : M), ↑(f (x₁ + x₂)) y = ↑(f x₁) y + ↑(f x₂) y) }, map_zero' := (_ : (fun y => { toZeroHom := { toFun := fun x => ↑(f x) y, map_zero' := (_ : ↑(f 0) y = 0) }, map_add' := (_ : ∀ (x₁ x₂ : M), ↑(f (x₁ + x₂)) y = ↑(f x₁) y + ↑(f x₂) y) }) 0 = 0) } (y₁ + y₂) = ZeroHom.toFun { toFun := fun y => { toZeroHom := { toFun := fun x => ↑(f x) y, map_zero' := (_ : ↑(f 0) y = 0) }, map_add' := (_ : ∀ (x₁ x₂ : M), ↑(f (x₁ + x₂)) y = ↑(f x₁) y + ↑(f x₂) y) }, map_zero' := (_ : (fun y => { toZeroHom := { toFun := fun x => ↑(f x) y, map_zero' := (_ : ↑(f 0) y = 0) }, map_add' := (_ : ∀ (x₁ x₂ : M), ↑(f (x₁ + x₂)) y = ↑(f x₁) y + ↑(f x₂) y) }) 0 = 0) } y₁ + ZeroHom.toFun { toFun := fun y => { toZeroHom := { toFun := fun x => ↑(f x) y, map_zero' := (_ : ↑(f 0) y = 0) }, map_add' := (_ : ∀ (x₁ x₂ : M), ↑(f (x₁ + x₂)) y = ↑(f x₁) y + ↑(f x₂) y) }, map_zero' := (_ : (fun y => { toZeroHom := { toFun := fun x => ↑(f x) y, map_zero' := (_ : ↑(f 0) y = 0) }, map_add' := (_ : ∀ (x₁ x₂ : M), ↑(f (x₁ + x₂)) y = ↑(f x₁) y + ↑(f x₂) y) }) 0 = 0) } y₂
Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.flip.proof_3 {M : Type u_1} {N : Type u_3} {P : Type u_2} {mM : } {mN : } {mP : } (f : M →+ N →+ P) :
(fun y => { toZeroHom := { toFun := fun x => ↑(f x) y, map_zero' := (_ : ↑(f 0) y = 0) }, map_add' := (_ : ∀ (x₁ x₂ : M), ↑(f (x₁ + x₂)) y = ↑(f x₁) y + ↑(f x₂) y) }) 0 = 0
Equations
• One or more equations did not get rendered due to their size.
def MonoidHom.flip {M : Type uM} {N : Type uN} {P : Type uP} {mM : } {mN : } {mP : } (f : M →* N →* P) :
N →* M →* P

flip arguments of f : M →* N →* P→* N →* P→* P

Equations
• One or more equations did not get rendered due to their size.
@[simp]
theorem AddMonoidHom.flip_apply {M : Type uM} {N : Type uN} {P : Type uP} :
∀ {x : } {x_1 : } {x_2 : } (f : M →+ N →+ P) (x_3 : M) (y : N), ↑(↑() y) x_3 = ↑(f x_3) y
@[simp]
theorem MonoidHom.flip_apply {M : Type uM} {N : Type uN} {P : Type uP} :
∀ {x : } {x_1 : } {x_2 : } (f : M →* N →* P) (x_3 : M) (y : N), ↑(↑() y) x_3 = ↑(f x_3) y
theorem AddMonoidHom.map_one₂ {M : Type uM} {N : Type uN} {P : Type uP} :
∀ {x : } {x_1 : } {x_2 : } (f : M →+ N →+ P) (n : N), ↑(f 0) n = 0
theorem MonoidHom.map_one₂ {M : Type uM} {N : Type uN} {P : Type uP} :
∀ {x : } {x_1 : } {x_2 : } (f : M →* N →* P) (n : N), ↑(f 1) n = 1
theorem AddMonoidHom.map_mul₂ {M : Type uM} {N : Type uN} {P : Type uP} :
∀ {x : } {x_1 : } {x_2 : } (f : M →+ N →+ P) (m₁ m₂ : M) (n : N), ↑(f (m₁ + m₂)) n = ↑(f m₁) n + ↑(f m₂) n
theorem MonoidHom.map_mul₂ {M : Type uM} {N : Type uN} {P : Type uP} :
∀ {x : } {x_1 : } {x_2 : } (f : M →* N →* P) (m₁ m₂ : M) (n : N), ↑(f (m₁ * m₂)) n = ↑(f m₁) n * ↑(f m₂) n
theorem AddMonoidHom.map_inv₂ {M : Type uM} {N : Type uN} {P : Type uP} :
∀ {x : } {x_1 : } {x_2 : } (f : M →+ N →+ P) (m : M) (n : N), ↑(f (-m)) n = -↑(f m) n
theorem MonoidHom.map_inv₂ {M : Type uM} {N : Type uN} {P : Type uP} :
∀ {x : } {x_1 : } {x_2 : } (f : M →* N →* P) (m : M) (n : N), ↑(f m⁻¹) n = (↑(f m) n)⁻¹
theorem AddMonoidHom.map_div₂ {M : Type uM} {N : Type uN} {P : Type uP} :
∀ {x : } {x_1 : } {x_2 : } (f : M →+ N →+ P) (m₁ m₂ : M) (n : N), ↑(f (m₁ - m₂)) n = ↑(f m₁) n - ↑(f m₂) n
theorem MonoidHom.map_div₂ {M : Type uM} {N : Type uN} {P : Type uP} :
∀ {x : } {x_1 : } {x_2 : } (f : M →* N →* P) (m₁ m₂ : M) (n : N), ↑(f (m₁ / m₂)) n = ↑(f m₁) n / ↑(f m₂) n
def AddMonoidHom.eval {M : Type uM} {N : Type uN} [inst : ] [inst : ] :
M →+ (M →+ N) →+ N

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.

Equations
@[simp]
theorem MonoidHom.eval_apply_apply {M : Type uM} {N : Type uN} [inst : ] [inst : ] (y : M) (x : M →* N) :
↑(MonoidHom.eval y) x = x y
@[simp]
theorem AddMonoidHom.eval_apply_apply {M : Type uM} {N : Type uN} [inst : ] [inst : ] (y : M) (x : M →+ N) :
↑(AddMonoidHom.eval y) x = x y
def MonoidHom.eval {M : Type uM} {N : Type uN} [inst : ] [inst : ] :
M →* (M →* N) →* N

Evaluation of a MonoidHom at a point as a monoid homomorphism. See also MonoidHom.apply for the evaluation of any function at a point.

Equations
def AddMonoidHom.compHom' {M : Type uM} {N : Type uN} {P : Type uP} [inst : ] [inst : ] [inst : ] (f : M →+ N) :
(N →+ P) →+ M →+ P

The expression λ g m, g (f m) as a AddMonoidHom. Equivalently, (λ g, AddMonoidHom.comp g f) as a AddMonoidHom.

This also exists in a LinearMap version, LinearMap.lcomp.

Equations
@[simp]
theorem AddMonoidHom.compHom'_apply_apply {M : Type uM} {N : Type uN} {P : Type uP} [inst : ] [inst : ] [inst : ] (f : M →+ N) (y : N →+ P) (x : M) :
↑(↑() y) x = y (f x)
@[simp]
theorem MonoidHom.compHom'_apply_apply {M : Type uM} {N : Type uN} {P : Type uP} [inst : ] [inst : ] [inst : ] (f : M →* N) (y : N →* P) (x : M) :
↑(↑() y) x = y (f x)
def MonoidHom.compHom' {M : Type uM} {N : Type uN} {P : Type uP} [inst : ] [inst : ] [inst : ] (f : M →* N) :
(N →* P) →* M →* P

The expression λ g m, g (f m) as a MonoidHom. Equivalently, (λ g, MonoidHom.comp g f) as a MonoidHom.

Equations
def AddMonoidHom.compHom {M : Type uM} {N : Type uN} {P : Type uP} [inst : ] [inst : ] [inst : ] :
(N →+ P) →+ (M →+ N) →+ M →+ P

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.

Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.compHom.proof_2 {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : ] [inst : ] [inst : ] :
(fun g => { toZeroHom := { toFun := , map_zero' := (_ : = 0) }, map_add' := (_ : ∀ (f₁ f₂ : M →+ N), AddMonoidHom.comp g (f₁ + f₂) = + ) }) 0 = 0
Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.compHom.proof_1 {M : Type u_1} {N : Type u_3} {P : Type u_2} [inst : ] [inst : ] [inst : ] (g : N →+ P) :
= 0
Equations
• (_ : = 0) = (_ : = 0)
def AddMonoidHom.compHom.proof_3 {M : Type u_3} {N : Type u_1} {P : Type u_2} [inst : ] [inst : ] [inst : ] (g₁ : N →+ P) (g₂ : N →+ P) :
Equations
• One or more equations did not get rendered due to their size.
@[simp]
theorem AddMonoidHom.compHom_apply_apply {M : Type uM} {N : Type uN} {P : Type uP} [inst : ] [inst : ] [inst : ] (g : N →+ P) (hmn : M →+ N) :
↑(AddMonoidHom.compHom g) hmn =
@[simp]
theorem MonoidHom.compHom_apply_apply {M : Type uM} {N : Type uN} {P : Type uP} [inst : ] [inst : ] [inst : ] (g : N →* P) (hmn : M →* N) :
↑(MonoidHom.compHom g) hmn = MonoidHom.comp g hmn
def MonoidHom.compHom {M : Type uM} {N : Type uN} {P : Type uP} [inst : ] [inst : ] [inst : ] :
(N →* P) →* (M →* N) →* M →* P

Composition of monoid morphisms (MonoidHom.comp) as a monoid morphism.

Note that unlike MonoidHom.comp_hom' this requires commutativity of N.

Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.flipHom.proof_1 {M : Type u_1} {N : Type u_2} {P : Type u_3} :
∀ {x : } {x_1 : } {x_2 : },
Equations
• (_ : ) = (_ : )
def AddMonoidHom.flipHom.proof_2 {M : Type u_1} {N : Type u_3} {P : Type u_2} :
∀ {x : } {x_1 : } {x_2 : } (x_3 x_4 : M →+ N →+ P), ZeroHom.toFun { toFun := AddMonoidHom.flip, map_zero' := (_ : ) } (x_3 + x_4) = ZeroHom.toFun { toFun := AddMonoidHom.flip, map_zero' := (_ : ) } (x_3 + x_4)
Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.flipHom {M : Type uM} {N : Type uN} {P : Type uP} :
{x : } → {x_1 : } → {x_2 : } → (M →+ N →+ P) →+ N →+ M →+ P

Flipping arguments of additive monoid morphisms (AddMonoidHom.flip) as an additive monoid morphism.

Equations
• One or more equations did not get rendered due to their size.
@[simp]
theorem MonoidHom.flipHom_apply {M : Type uM} {N : Type uN} {P : Type uP} :
∀ {x : } {x_1 : } {x_2 : } (f : M →* N →* P), MonoidHom.flipHom f =
@[simp]
theorem AddMonoidHom.flipHom_apply {M : Type uM} {N : Type uN} {P : Type uP} :
∀ {x : } {x_1 : } {x_2 : } (f : M →+ N →+ P), AddMonoidHom.flipHom f =
def MonoidHom.flipHom {M : Type uM} {N : Type uN} {P : Type uP} :
{x : } → {x_1 : } → {x_2 : } → (M →* N →* P) →* N →* M →* P

Flipping arguments of monoid morphisms (MonoidHom.flip) as a monoid morphism.

Equations
• One or more equations did not get rendered due to their size.
def AddMonoidHom.compl₂ {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : ] [inst : ] [inst : ] [inst : ] (f : M →+ N →+ P) (g : Q →+ N) :
M →+ Q →+ P

The expression λ m q, f m (g q) as an AddMonoidHom.

Note that the expression λ q n, f (g q) n is simply AddMonoidHom.comp.

This also exists as a LinearMap version, LinearMap.compl₂

Equations
def MonoidHom.compl₂ {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : ] [inst : ] [inst : ] [inst : ] (f : M →* N →* P) (g : Q →* N) :
M →* Q →* P

The expression λ m q, f m (g q) as a MonoidHom.

Note that the expression λ q n, f (g q) n is simply MonoidHom.comp.

Equations
@[simp]
theorem AddMonoidHom.compl₂_apply {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : ] [inst : ] [inst : ] [inst : ] (f : M →+ N →+ P) (g : Q →+ N) (m : M) (q : Q) :
↑(↑() m) q = ↑(f m) (g q)
@[simp]
theorem MonoidHom.compl₂_apply {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : ] [inst : ] [inst : ] [inst : ] (f : M →* N →* P) (g : Q →* N) (m : M) (q : Q) :
↑(↑() m) q = ↑(f m) (g q)
def AddMonoidHom.compr₂ {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : ] [inst : ] [inst : ] [inst : ] (f : M →+ N →+ P) (g : P →+ Q) :
M →+ N →+ Q

The expression λ m n, g (f m n) as an AddMonoidHom.

This also exists as a LinearMap version, LinearMap.compr₂

Equations
def MonoidHom.compr₂ {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : ] [inst : ] [inst : ] [inst : ] (f : M →* N →* P) (g : P →* Q) :
M →* N →* Q

The expression λ m n, g (f m n) as a MonoidHom.

Equations
@[simp]
theorem AddMonoidHom.compr₂_apply {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : ] [inst : ] [inst : ] [inst : ] (f : M →+ N →+ P) (g : P →+ Q) (m : M) (n : N) :
↑(↑() m) n = g (↑(f m) n)
@[simp]
theorem MonoidHom.compr₂_apply {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : ] [inst : ] [inst : ] [inst : ] (f : M →* N →* P) (g : P →* Q) (m : M) (n : N) :
↑(↑() m) n = g (↑(f m) n)

### Miscellaneous definitions #

Due to the fact this file imports Algebra.GroupPower.Basic, it is not possible to import it in some of the lower-level files like Algebra.Ring.Basic. The following lemmas should be rehomed if the import structure permits them to be.

def AddMonoidHom.mul {R : Type u_1} [inst : ] :
R →+ R →+ R

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.

Equations
• One or more equations did not get rendered due to their size.
theorem AddMonoidHom.mul_apply {R : Type u_1} [inst : ] (x : R) (y : R) :
↑(AddMonoidHom.mul x) y = x * y
@[simp]
theorem AddMonoidHom.coe_mul {R : Type u_1} [inst : ] :
@[simp]
theorem AddMonoidHom.coe_flip_mul {R : Type u_1} [inst : ] :
theorem AddMonoidHom.map_mul_iff {R : Type u_1} {S : Type u_2} [inst : ] [inst : ] (f : R →+ S) :
(∀ (x y : R), f (x * y) = f x * f y) AddMonoidHom.compr₂ AddMonoidHom.mul f = AddMonoidHom.compl₂ (AddMonoidHom.comp AddMonoidHom.mul f) f

An AddMonoidHom preserves multiplication if pre- and post- composition with AddMonoidHom.mul are equivalent. By converting the statement into an equality of AddMonoidHoms, this lemma allows various specialized ext lemmas about →+→+ to then be applied.

@[simp]
theorem AddMonoid.End.mulLeft_apply_apply {R : Type u_1} [inst : ] (r : R) :
∀ (x : R), ↑(AddMonoid.End.mulLeft r) x = r * x
def AddMonoid.End.mulLeft {R : Type u_1} [inst : ] :

The left multiplication map: (a, b) ↦ a * b↦ a * b. See also AddMonoidHom.mulLeft.

Equations
The right multiplication map: (a, b) ↦ b * a↦ b * a. See also AddMonoidHom.mulRight.