mathlib documentation

group_theory.group_action.defs

Definitions of group actions #

This file defines a hierarchy of group action type-classes on top of the previously defined notation classes has_scalar and its additive version has_vadd:

The hierarchy is extended further by module, defined elsewhere.

Also provided are typeclasses for faithful and transitive actions, and typeclasses regarding the interaction of different group actions,

Notation #

Implementation details #

This file should avoid depending on other parts of group_theory, to avoid import cycles. More sophisticated lemmas belong in group_theory.group_action.

Tags #

group action

Faithful actions #

@[class]
structure has_faithful_vadd (G : Type u_10) (P : Type u_11) [has_vadd G P] :
Prop
  • eq_of_vadd_eq_vadd : ∀ {g₁ g₂ : G}, (∀ (p : P), g₁ +ᵥ p = g₂ +ᵥ p)g₁ = g₂

Typeclass for faithful actions.

Instances of this typeclass
theorem vadd_left_injective' {M : Type u_1} {α : Type u_6} [has_vadd M α] [has_faithful_vadd M α] :
theorem smul_left_injective' {M : Type u_1} {α : Type u_6} [has_scalar M α] [has_faithful_smul M α] :
@[protected, instance]
def has_mul.to_has_scalar (α : Type u_1) [has_mul α] :

See also monoid.to_mul_action and mul_zero_class.to_smul_with_zero.

Equations
@[protected, instance]
def has_add.to_has_scalar (α : Type u_1) [has_add α] :
has_vadd α α
Equations
@[simp]
theorem vadd_eq_add (α : Type u_1) [has_add α] {a a' : α} :
a +ᵥ a' = a + a'
@[simp]
theorem smul_eq_mul (α : Type u_1) [has_mul α] {a a' : α} :
a a' = a * a'
theorem add_action.ext {G : Type u_10} {P : Type u_11} {_inst_1 : add_monoid G} (x y : add_action G P) (h : add_action.to_has_vadd = add_action.to_has_vadd) :
x = y
@[ext, class]
structure add_action (G : Type u_10) (P : Type u_11) [add_monoid G] :
Type (max u_10 u_11)
  • to_has_vadd : has_vadd G P
  • zero_vadd : ∀ (p : P), 0 +ᵥ p = p
  • add_vadd : ∀ (g₁ g₂ : G) (p : P), g₁ + g₂ +ᵥ p = g₁ +ᵥ (g₂ +ᵥ p)

Type class for additive monoid actions.

Instances of this typeclass
Instances of other typeclasses for add_action
  • add_action.has_sizeof_inst
theorem add_action.ext_iff {G : Type u_10} {P : Type u_11} {_inst_1 : add_monoid G} (x y : add_action G P) :
theorem mul_action.ext {α : Type u_10} {β : Type u_11} {_inst_1 : monoid α} (x y : mul_action α β) (h : mul_action.to_has_scalar = mul_action.to_has_scalar) :
x = y
@[ext, class]
structure mul_action (α : Type u_10) (β : Type u_11) [monoid α] :
Type (max u_10 u_11)
  • to_has_scalar : has_scalar α β
  • one_smul : ∀ (b : β), 1 b = b
  • mul_smul : ∀ (x y : α) (b : β), (x * y) b = x y b

Typeclass for multiplicative actions by monoids. This generalizes group actions.

Instances of this typeclass
Instances of other typeclasses for mul_action
  • mul_action.has_sizeof_inst
theorem mul_action.ext_iff {α : Type u_10} {β : Type u_11} {_inst_1 : monoid α} (x y : mul_action α β) :
@[protected, instance]
def additive.add_action {α : Type u_6} {β : Type u_7} [monoid α] [mul_action α β] :
Equations
@[simp]
theorem additive.of_mul_vadd {α : Type u_6} {β : Type u_7} [monoid α] [mul_action α β] (a : α) (b : β) :
@[protected, instance]
def multiplicative.mul_action {α : Type u_6} {β : Type u_7} [add_monoid α] [add_action α β] :
Equations
@[simp]
theorem multiplicative.of_add_smul {α : Type u_6} {β : Type u_7} [add_monoid α] [add_action α β] (a : α) (b : β) :

(Pre)transitive action #

M acts pretransitively on α if for any x y there is g such that g • x = y (or g +ᵥ x = y for an additive action). A transitive action should furthermore have α nonempty.

In this section we define typeclasses mul_action.is_pretransitive and add_action.is_pretransitive and provide mul_action.exists_smul_eq/add_action.exists_vadd_eq, mul_action.surjective_smul/add_action.surjective_vadd as public interface to access this property. We do not provide typeclasses *_action.is_transitive; users should assume [mul_action.is_pretransitive M α] [nonempty α] instead.

@[class]
structure add_action.is_pretransitive (M : Type u_10) (α : Type u_11) [has_vadd M α] :
Prop
  • exists_vadd_eq : ∀ (x y : α), ∃ (g : M), g +ᵥ x = y

M acts pretransitively on α if for any x y there is g such that g +ᵥ x = y. A transitive action should furthermore have α nonempty.

Instances of this typeclass
@[class]
structure mul_action.is_pretransitive (M : Type u_10) (α : Type u_11) [has_scalar M α] :
Prop
  • exists_smul_eq : ∀ (x y : α), ∃ (g : M), g x = y

M acts pretransitively on α if for any x y there is g such that g • x = y. A transitive action should furthermore have α nonempty.

Instances of this typeclass
theorem add_action.exists_vadd_eq (M : Type u_1) {α : Type u_6} [has_vadd M α] [add_action.is_pretransitive M α] (x y : α) :
∃ (m : M), m +ᵥ x = y
theorem mul_action.exists_smul_eq (M : Type u_1) {α : Type u_6} [has_scalar M α] [mul_action.is_pretransitive M α] (x y : α) :
∃ (m : M), m x = y
theorem mul_action.surjective_smul (M : Type u_1) {α : Type u_6} [has_scalar M α] [mul_action.is_pretransitive M α] (x : α) :
function.surjective (λ (c : M), c x)
theorem add_action.surjective_vadd (M : Type u_1) {α : Type u_6} [has_vadd M α] [add_action.is_pretransitive M α] (x : α) :
function.surjective (λ (c : M), c +ᵥ x)
@[protected, instance]
@[protected, instance]

The regular action of a group on itself is transitive.

Scalar tower and commuting actions #

@[class]
structure smul_comm_class (M : Type u_10) (N : Type u_11) (α : Type u_12) [has_scalar M α] [has_scalar N α] :
Prop
  • smul_comm : ∀ (m : M) (n : N) (a : α), m n a = n m a

A typeclass mixin saying that two multiplicative actions on the same space commute.

Instances of this typeclass
theorem smul_comm_class.symm (M : Type u_1) (N : Type u_2) (α : Type u_3) [has_scalar M α] [has_scalar N α] [smul_comm_class M N α] :

Commutativity of actions is a symmetric relation. This lemma can't be an instance because this would cause a loop in the instance search graph.

theorem vadd_comm_class.symm (M : Type u_1) (N : Type u_2) (α : Type u_3) [has_vadd M α] [has_vadd N α] [vadd_comm_class M N α] :

Commutativity of additive actions is a symmetric relation. This lemma can't be an instance because this would cause a loop in the instance search graph.

@[protected, instance]
def vadd_comm_class_self (M : Type u_1) (α : Type u_2) [add_comm_monoid M] [add_action M α] :
@[protected, instance]
def smul_comm_class_self (M : Type u_1) (α : Type u_2) [comm_monoid M] [mul_action M α] :
@[class]
structure is_scalar_tower (M : Type u_10) (N : Type u_11) (α : Type u_12) [has_scalar M N] [has_scalar N α] [has_scalar M α] :
Prop
  • smul_assoc : ∀ (x : M) (y : N) (z : α), (x y) z = x y z

An instance of is_scalar_tower M N α states that the multiplicative action of M on α is determined by the multiplicative actions of M on N and N on α.

Instances of this typeclass
@[simp]
theorem smul_assoc {α : Type u_6} {M : Type u_1} {N : Type u_2} [has_scalar M N] [has_scalar N α] [has_scalar M α] [is_scalar_tower M N α] (x : M) (y : N) (z : α) :
(x y) z = x y z
@[protected, instance]
def semigroup.is_scalar_tower {α : Type u_6} [semigroup α] :
@[class]
structure is_central_scalar (M : Type u_10) (α : Type u_11) [has_scalar M α] [has_scalar Mᵐᵒᵖ α] :
Prop

A typeclass indicating that the right (aka mul_opposite) and left actions by M on α are equal, that is that M acts centrally on α. This can be thought of as a version of commutativity for .

Instances of this typeclass
theorem is_central_scalar.unop_smul_eq_smul {M : Type u_1} {α : Type u_2} [has_scalar M α] [has_scalar Mᵐᵒᵖ α] [is_central_scalar M α] (m : Mᵐᵒᵖ) (a : α) :
@[protected, instance]
def smul_comm_class.op_left {M : Type u_1} {N : Type u_2} {α : Type u_6} [has_scalar M α] [has_scalar Mᵐᵒᵖ α] [is_central_scalar M α] [has_scalar N α] [smul_comm_class M N α] :
@[protected, instance]
def smul_comm_class.op_right {M : Type u_1} {N : Type u_2} {α : Type u_6} [has_scalar M α] [has_scalar N α] [has_scalar Nᵐᵒᵖ α] [is_central_scalar N α] [smul_comm_class M N α] :
@[protected, instance]
def is_scalar_tower.op_left {M : Type u_1} {N : Type u_2} {α : Type u_6} [has_scalar M α] [has_scalar Mᵐᵒᵖ α] [is_central_scalar M α] [has_scalar M N] [has_scalar Mᵐᵒᵖ N] [is_central_scalar M N] [has_scalar N α] [is_scalar_tower M N α] :
@[protected, instance]
def is_scalar_tower.op_right {M : Type u_1} {N : Type u_2} {α : Type u_6} [has_scalar M α] [has_scalar M N] [has_scalar N α] [has_scalar Nᵐᵒᵖ α] [is_central_scalar N α] [is_scalar_tower M N α] :
@[simp]
def has_vadd.comp.vadd {M : Type u_1} {N : Type u_2} {α : Type u_6} [has_vadd M α] (g : N → M) (n : N) (a : α) :
α

Auxiliary definition for has_vadd.comp, add_action.comp_hom, etc.

Equations
@[simp]
def has_scalar.comp.smul {M : Type u_1} {N : Type u_2} {α : Type u_6} [has_scalar M α] (g : N → M) (n : N) (a : α) :
α

Auxiliary definition for has_scalar.comp, mul_action.comp_hom, distrib_mul_action.comp_hom, module.comp_hom, etc.

Equations
def has_vadd.comp {M : Type u_1} {N : Type u_2} (α : Type u_6) [has_vadd M α] (g : N → M) :

An additive action of M on α and a function N → M induces an additive action of N on α

Equations
def has_scalar.comp {M : Type u_1} {N : Type u_2} (α : Type u_6) [has_scalar M α] (g : N → M) :

An action of M on α and a function N → M induces an action of N on α.

See note [reducible non-instances]. Since this is reducible, we make sure to go via has_scalar.comp.smul to prevent typeclass inference unfolding too far.

Equations
theorem has_scalar.comp.is_scalar_tower {M : Type u_1} {N : Type u_2} {α : Type u_6} {β : Type u_7} [has_scalar M α] [has_scalar M β] [has_scalar α β] [is_scalar_tower M α β] (g : N → M) :

Given a tower of scalar actions M → α → β, if we use has_scalar.comp to pull back both of M's actions by a map g : N → M, then we obtain a new tower of scalar actions N → α → β.

This cannot be an instance because it can cause infinite loops whenever the has_scalar arguments are still metavariables.

theorem has_scalar.comp.smul_comm_class {M : Type u_1} {N : Type u_2} {α : Type u_6} {β : Type u_7} [has_scalar M α] [has_scalar β α] [smul_comm_class M β α] (g : N → M) :

This cannot be an instance because it can cause infinite loops whenever the has_scalar arguments are still metavariables.

theorem has_scalar.comp.smul_comm_class' {M : Type u_1} {N : Type u_2} {α : Type u_6} {β : Type u_7} [has_scalar M α] [has_scalar β α] [smul_comm_class β M α] (g : N → M) :

This cannot be an instance because it can cause infinite loops whenever the has_scalar arguments are still metavariables.

theorem add_vadd_comm {α : Type u_6} {β : Type u_7} [has_add β] [has_vadd α β] [vadd_comm_class α β β] (s : α) (x y : β) :
x + (s +ᵥ y) = s +ᵥ (x + y)
theorem mul_smul_comm {α : Type u_6} {β : Type u_7} [has_mul β] [has_scalar α β] [smul_comm_class α β β] (s : α) (x y : β) :
x * s y = s (x * y)

Note that the smul_comm_class α β β typeclass argument is usually satisfied by algebra α β.

theorem smul_mul_assoc {α : Type u_6} {β : Type u_7} [has_mul β] [has_scalar α β] [is_scalar_tower α β β] (r : α) (x y : β) :
r x * y = r (x * y)

Note that the is_scalar_tower α β β typeclass argument is usually satisfied by algebra α β.

theorem smul_smul_smul_comm {α : Type u_6} {β : Type u_7} {γ : Type u_8} {δ : Type u_9} [has_scalar α β] [has_scalar α γ] [has_scalar β δ] [has_scalar α δ] [has_scalar γ δ] [is_scalar_tower α β δ] [is_scalar_tower α γ δ] [smul_comm_class β γ δ] (a : α) (b : β) (c : γ) (d : δ) :
(a b) c d = (a c) b d
theorem commute.smul_right {M : Type u_1} {α : Type u_6} [has_scalar M α] [has_mul α] [smul_comm_class M α α] [is_scalar_tower M α α] {a b : α} (h : commute a b) (r : M) :
commute a (r b)
theorem commute.smul_left {M : Type u_1} {α : Type u_6} [has_scalar M α] [has_mul α] [smul_comm_class M α α] [is_scalar_tower M α α] {a b : α} (h : commute a b) (r : M) :
commute (r a) b
theorem ite_smul {M : Type u_1} {α : Type u_6} [has_scalar M α] (p : Prop) [decidable p] (a₁ a₂ : M) (b : α) :
ite p a₁ a₂ b = ite p (a₁ b) (a₂ b)
theorem ite_vadd {M : Type u_1} {α : Type u_6} [has_vadd M α] (p : Prop) [decidable p] (a₁ a₂ : M) (b : α) :
ite p a₁ a₂ +ᵥ b = ite p (a₁ +ᵥ b) (a₂ +ᵥ b)
theorem smul_ite {M : Type u_1} {α : Type u_6} [has_scalar M α] (p : Prop) [decidable p] (a : M) (b₁ b₂ : α) :
a ite p b₁ b₂ = ite p (a b₁) (a b₂)
theorem vadd_ite {M : Type u_1} {α : Type u_6} [has_vadd M α] (p : Prop) [decidable p] (a : M) (b₁ b₂ : α) :
a +ᵥ ite p b₁ b₂ = ite p (a +ᵥ b₁) (a +ᵥ b₂)
theorem smul_smul {M : Type u_1} {α : Type u_6} [monoid M] [mul_action M α] (a₁ a₂ : M) (b : α) :
a₁ a₂ b = (a₁ * a₂) b
theorem vadd_vadd {M : Type u_1} {α : Type u_6} [add_monoid M] [add_action M α] (a₁ a₂ : M) (b : α) :
a₁ +ᵥ (a₂ +ᵥ b) = a₁ + a₂ +ᵥ b
@[simp]
theorem one_smul (M : Type u_1) {α : Type u_6} [monoid M] [mul_action M α] (b : α) :
1 b = b
@[simp]
theorem zero_vadd (M : Type u_1) {α : Type u_6} [add_monoid M] [add_action M α] (b : α) :
0 +ᵥ b = b
theorem one_smul_eq_id (M : Type u_1) {α : Type u_6} [monoid M] [mul_action M α] :

has_scalar version of one_mul_eq_id

theorem zero_vadd_eq_id (M : Type u_1) {α : Type u_6} [add_monoid M] [add_action M α] :
theorem comp_smul_left (M : Type u_1) {α : Type u_6} [monoid M] [mul_action M α] (a₁ a₂ : M) :

has_scalar version of comp_mul_left

theorem comp_vadd_left (M : Type u_1) {α : Type u_6} [add_monoid M] [add_action M α] (a₁ a₂ : M) :
@[protected]
def function.injective.mul_action {M : Type u_1} {α : Type u_6} {β : Type u_7} [monoid M] [mul_action M α] [has_scalar M β] (f : β → α) (hf : function.injective f) (smul : ∀ (c : M) (x : β), f (c x) = c f x) :

Pullback a multiplicative action along an injective map respecting . See note [reducible non-instances].

Equations
@[protected]
def function.injective.add_action {M : Type u_1} {α : Type u_6} {β : Type u_7} [add_monoid M] [add_action M α] [has_vadd M β] (f : β → α) (hf : function.injective f) (smul : ∀ (c : M) (x : β), f (c +ᵥ x) = c +ᵥ f x) :

Pullback an additive action along an injective map respecting +ᵥ.

Equations
@[protected]
def function.surjective.add_action {M : Type u_1} {α : Type u_6} {β : Type u_7} [add_monoid M] [add_action M α] [has_vadd M β] (f : α → β) (hf : function.surjective f) (smul : ∀ (c : M) (x : α), f (c +ᵥ x) = c +ᵥ f x) :

Pushforward an additive action along a surjective map respecting +ᵥ.

Equations
@[protected]
def function.surjective.mul_action {M : Type u_1} {α : Type u_6} {β : Type u_7} [monoid M] [mul_action M α] [has_scalar M β] (f : α → β) (hf : function.surjective f) (smul : ∀ (c : M) (x : α), f (c x) = c f x) :

Pushforward a multiplicative action along a surjective map respecting . See note [reducible non-instances].

Equations
def function.surjective.mul_action_left {R : Type u_1} {S : Type u_2} {M : Type u_3} [monoid R] [mul_action R M] [monoid S] [has_scalar S M] (f : R →* S) (hf : function.surjective f) (hsmul : ∀ (c : R) (x : M), f c x = c x) :

Push forward the action of R on M along a compatible surjective map f : R →* S.

See also function.surjective.distrib_mul_action_left and function.surjective.module_left.

Equations
def function.surjective.add_action_left {R : Type u_1} {S : Type u_2} {M : Type u_3} [add_monoid R] [add_action R M] [add_monoid S] [has_vadd S M] (f : R →+ S) (hf : function.surjective f) (hsmul : ∀ (c : R) (x : M), f c +ᵥ x = c +ᵥ x) :

Push forward the action of R on M along a compatible surjective map f : R →+ S.

Equations
@[protected, instance]
def monoid.to_mul_action (M : Type u_1) [monoid M] :

The regular action of a monoid on itself by left multiplication.

This is promoted to a module by semiring.to_module.

Equations
@[protected, instance]
def add_monoid.to_add_action (M : Type u_1) [add_monoid M] :

The regular action of a monoid on itself by left addition.

This is promoted to an add_torsor by add_group_is_add_torsor.

Equations
@[protected, instance]
def is_scalar_tower.left (M : Type u_1) {α : Type u_6} [monoid M] [mul_action M α] :
theorem smul_mul_smul {M : Type u_1} {α : Type u_6} [monoid M] [mul_action M α] [has_mul α] (r s : M) (x y : α) [is_scalar_tower M α α] [smul_comm_class M α α] :
r x * s y = (r * s) (x * y)

Note that the is_scalar_tower M α α and smul_comm_class M α α typeclass arguments are usually satisfied by algebra M α.

def mul_action.to_fun (M : Type u_1) (α : Type u_6) [monoid M] [mul_action M α] :
α M → α

Embedding of α into functions M → α induced by a multiplicative action of M on α.

Equations
def add_action.to_fun (M : Type u_1) (α : Type u_6) [add_monoid M] [add_action M α] :
α M → α

Embedding of α into functions M → α induced by an additive action of M on α.

Equations
@[simp]
theorem mul_action.to_fun_apply {M : Type u_1} {α : Type u_6} [monoid M] [mul_action M α] (x : M) (y : α) :
(mul_action.to_fun M α) y x = x y
@[simp]
theorem add_action.to_fun_apply {M : Type u_1} {α : Type u_6} [add_monoid M] [add_action M α] (x : M) (y : α) :
(add_action.to_fun M α) y x = x +ᵥ y
def mul_action.comp_hom {M : Type u_1} {N : Type u_2} (α : Type u_6) [monoid M] [mul_action M α] [monoid N] (g : N →* M) :

A multiplicative action of M on α and a monoid homomorphism N → M induce a multiplicative action of N on α.

See note [reducible non-instances].

Equations
def add_action.comp_hom {M : Type u_1} {N : Type u_2} (α : Type u_6) [add_monoid M] [add_action M α] [add_monoid N] (g : N →+ M) :

An additive action of M on α and an additive monoid homomorphism N → M induce an additive action of N on α.

See note [reducible non-instances].

Equations
@[simp]
theorem smul_one_smul {α : Type u_6} {M : Type u_1} (N : Type u_2) [monoid N] [has_scalar M N] [mul_action N α] [has_scalar M α] [is_scalar_tower M N α] (x : M) (y : α) :
(x 1) y = x y
@[simp]
theorem smul_one_mul {M : Type u_1} {N : Type u_2} [monoid N] [has_scalar M N] [is_scalar_tower M N N] (x : M) (y : N) :
x 1 * y = x y
@[simp]
theorem add_vadd_zero {M : Type u_1} {N : Type u_2} [add_zero_class N] [has_vadd M N] [vadd_comm_class M N N] (x : M) (y : N) :
y + (x +ᵥ 0) = x +ᵥ y
@[simp]
theorem mul_smul_one {M : Type u_1} {N : Type u_2} [mul_one_class N] [has_scalar M N] [smul_comm_class M N N] (x : M) (y : N) :
y * x 1 = x y
theorem is_scalar_tower.of_smul_one_mul {M : Type u_1} {N : Type u_2} [monoid N] [has_scalar M N] (h : ∀ (x : M) (y : N), x 1 * y = x y) :
theorem smul_comm_class.of_mul_smul_one {M : Type u_1} {N : Type u_2} [monoid N] [has_scalar M N] (H : ∀ (x : M) (y : N), y * x 1 = x y) :
theorem vadd_comm_class.of_add_vadd_zero {M : Type u_1} {N : Type u_2} [add_monoid N] [has_vadd M N] (H : ∀ (x : M) (y : N), y + (x +ᵥ 0) = x +ᵥ y) :
theorem distrib_mul_action.ext {M : Type u_10} {A : Type u_11} {_inst_1 : monoid M} {_inst_2 : add_monoid A} (x y : distrib_mul_action M A) (h : distrib_mul_action.to_mul_action = distrib_mul_action.to_mul_action) :
x = y
@[ext, class]
structure distrib_mul_action (M : Type u_10) (A : Type u_11) [monoid M] [add_monoid A] :
Type (max u_10 u_11)
  • to_mul_action : mul_action M A
  • smul_add : ∀ (r : M) (x y : A), r (x + y) = r x + r y
  • smul_zero : ∀ (r : M), r 0 = 0

Typeclass for multiplicative actions on additive structures. This generalizes group modules.

Instances of this typeclass
Instances of other typeclasses for distrib_mul_action
  • distrib_mul_action.has_sizeof_inst
theorem distrib_mul_action.ext_iff {M : Type u_10} {A : Type u_11} {_inst_1 : monoid M} {_inst_2 : add_monoid A} (x y : distrib_mul_action M A) :
@[simp]
theorem smul_add {M : Type u_1} {A : Type u_4} [monoid M] [add_monoid A] [distrib_mul_action M A] (a : M) (b₁ b₂ : A) :
a (b₁ + b₂) = a b₁ + a b₂
@[simp]
theorem smul_zero {M : Type u_1} {A : Type u_4} [monoid M] [add_monoid A] [distrib_mul_action M A] (a : M) :
a 0 = 0
@[protected]
def function.injective.distrib_mul_action {M : Type u_1} {A : Type u_4} {B : Type u_5} [monoid M] [add_monoid A] [distrib_mul_action M A] [add_monoid B] [has_scalar M B] (f : B →+ A) (hf : function.injective f) (smul : ∀ (c : M) (x : B), f (c x) = c f x) :

Pullback a distributive multiplicative action along an injective additive monoid homomorphism. See note [reducible non-instances].

Equations
@[protected]
def function.surjective.distrib_mul_action {M : Type u_1} {A : Type u_4} {B : Type u_5} [monoid M] [add_monoid A] [distrib_mul_action M A] [add_monoid B] [has_scalar M B] (f : A →+ B) (hf : function.surjective f) (smul : ∀ (c : M) (x : A), f (c x) = c f x) :

Pushforward a distributive multiplicative action along a surjective additive monoid homomorphism. See note [reducible non-instances].

Equations
def function.surjective.distrib_mul_action_left {R : Type u_1} {S : Type u_2} {M : Type u_3} [monoid R] [add_monoid M] [distrib_mul_action R M] [monoid S] [has_scalar S M] (f : R →* S) (hf : function.surjective f) (hsmul : ∀ (c : R) (x : M), f c x = c x) :

Push forward the action of R on M along a compatible surjective map f : R →* S.

See also function.surjective.mul_action_left and function.surjective.module_left.

Equations
def distrib_mul_action.comp_hom {M : Type u_1} {N : Type u_2} (A : Type u_4) [monoid M] [add_monoid A] [distrib_mul_action M A] [monoid N] (f : N →* M) :

Compose a distrib_mul_action with a monoid_hom, with action f r' • m. See note [reducible non-instances].

Equations
def distrib_mul_action.to_add_monoid_hom {M : Type u_1} (A : Type u_4) [monoid M] [add_monoid A] [distrib_mul_action M A] (x : M) :
A →+ A

Each element of the monoid defines a additive monoid homomorphism.

Equations
@[simp]
theorem distrib_mul_action.to_add_monoid_hom_apply {M : Type u_1} (A : Type u_4) [monoid M] [add_monoid A] [distrib_mul_action M A] (x : M) (ᾰ : A) :
def distrib_mul_action.to_add_monoid_End (M : Type u_1) (A : Type u_4) [monoid M] [add_monoid A] [distrib_mul_action M A] :

Each element of the monoid defines an additive monoid homomorphism.

Equations
@[protected, instance]
def add_monoid.nat_smul_comm_class (M : Type u_1) (A : Type u_4) [monoid M] [add_monoid A] [distrib_mul_action M A] :
@[protected, instance]
def add_monoid.nat_smul_comm_class' (M : Type u_1) (A : Type u_4) [monoid M] [add_monoid A] [distrib_mul_action M A] :
@[protected, instance]
def add_group.int_smul_comm_class {M : Type u_1} {A : Type u_4} [monoid M] [add_group A] [distrib_mul_action M A] :
@[protected, instance]
def add_group.int_smul_comm_class' {M : Type u_1} {A : Type u_4} [monoid M] [add_group A] [distrib_mul_action M A] :
@[simp]
theorem smul_neg {M : Type u_1} {A : Type u_4} [monoid M] [add_group A] [distrib_mul_action M A] (r : M) (x : A) :
r -x = -(r x)
theorem smul_sub {M : Type u_1} {A : Type u_4} [monoid M] [add_group A] [distrib_mul_action M A] (r : M) (x y : A) :
r (x - y) = r x - r y
theorem mul_distrib_mul_action.ext {M : Type u_10} {A : Type u_11} {_inst_1 : monoid M} {_inst_2 : monoid A} (x y : mul_distrib_mul_action M A) (h : mul_distrib_mul_action.to_mul_action = mul_distrib_mul_action.to_mul_action) :
x = y
theorem mul_distrib_mul_action.ext_iff {M : Type u_10} {A : Type u_11} {_inst_1 : monoid M} {_inst_2 : monoid A} (x y : mul_distrib_mul_action M A) :
@[simp]
theorem smul_mul' {M : Type u_1} {A : Type u_4} [monoid M] [monoid A] [mul_distrib_mul_action M A] (a : M) (b₁ b₂ : A) :
a (b₁ * b₂) = a b₁ * a b₂
@[protected]
def function.injective.mul_distrib_mul_action {M : Type u_1} {A : Type u_4} {B : Type u_5} [monoid M] [monoid A] [mul_distrib_mul_action M A] [monoid B] [has_scalar M B] (f : B →* A) (hf : function.injective f) (smul : ∀ (c : M) (x : B), f (c x) = c f x) :

Pullback a multiplicative distributive multiplicative action along an injective monoid homomorphism. See note [reducible non-instances].

Equations
@[protected]
def function.surjective.mul_distrib_mul_action {M : Type u_1} {A : Type u_4} {B : Type u_5} [monoid M] [monoid A] [mul_distrib_mul_action M A] [monoid B] [has_scalar M B] (f : A →* B) (hf : function.surjective f) (smul : ∀ (c : M) (x : A), f (c x) = c f x) :

Pushforward a multiplicative distributive multiplicative action along a surjective monoid homomorphism. See note [reducible non-instances].

Equations
def mul_distrib_mul_action.comp_hom {M : Type u_1} {N : Type u_2} (A : Type u_4) [monoid M] [monoid A] [mul_distrib_mul_action M A] [monoid N] (f : N →* M) :

Compose a mul_distrib_mul_action with a monoid_hom, with action f r' • m. See note [reducible non-instances].

Equations
def mul_distrib_mul_action.to_monoid_hom {M : Type u_1} (A : Type u_4) [monoid M] [monoid A] [mul_distrib_mul_action M A] (r : M) :
A →* A

Scalar multiplication by r as a monoid_hom.

Equations
@[simp]
theorem mul_distrib_mul_action.to_monoid_hom_apply {M : Type u_1} {A : Type u_4} [monoid M] [monoid A] [mul_distrib_mul_action M A] (r : M) (x : A) :
def mul_distrib_mul_action.to_monoid_End (M : Type u_1) (A : Type u_4) [monoid M] [monoid A] [mul_distrib_mul_action M A] :

Each element of the monoid defines a monoid homomorphism.

Equations
@[simp]
theorem smul_inv' {M : Type u_1} {A : Type u_4} [monoid M] [group A] [mul_distrib_mul_action M A] (r : M) (x : A) :
r x⁻¹ = (r x)⁻¹
theorem smul_div' {M : Type u_1} {A : Type u_4} [monoid M] [group A] [mul_distrib_mul_action M A] (r : M) (x y : A) :
r (x / y) = r x / r y
@[protected]
def function.End (α : Type u_6) :
Type u_6

The monoid of endomorphisms.

Note that this is generalized by category_theory.End to categories other than Type u.

Equations
Instances for function.End
@[protected, instance]
def function.End.monoid (α : Type u_6) :
Equations
@[protected, instance]
def function.End.inhabited (α : Type u_6) :
Equations
@[simp]
theorem function.End.smul_def {α : Type u_6} (f : function.End α) (a : α) :
f a = f a
@[protected, instance]

function.End.apply_mul_action is faithful.

@[protected, instance]

The tautological action by add_monoid.End α on α.

This generalizes function.End.apply_mul_action.

Equations
@[simp]
theorem add_monoid.End.smul_def {α : Type u_6} [add_monoid α] (f : add_monoid.End α) (a : α) :
f a = f a
def mul_action.to_End_hom {M : Type u_1} {α : Type u_6} [monoid M] [mul_action M α] :

The monoid hom representing a monoid action.

When M is a group, see mul_action.to_perm_hom.

Equations
def mul_action.of_End_hom {M : Type u_1} {α : Type u_6} [monoid M] (f : M →* function.End α) :

The monoid action induced by a monoid hom to function.End α

See note [reducible non-instances].

Equations
@[protected, instance]
def add_action.function_End {α : Type u_6} :

The tautological additive action by additive (function.End α) on α.

Equations
def add_action.to_End_hom {M : Type u_1} {α : Type u_6} [add_monoid M] [add_action M α] :

The additive monoid hom representing an additive monoid action.

When M is a group, see add_action.to_perm_hom.

Equations
def add_action.of_End_hom {M : Type u_1} {α : Type u_6} [add_monoid M] (f : M →+ additive (function.End α)) :

The additive action induced by a hom to additive (function.End α)

See note [reducible non-instances].

Equations