Definitions of group actions

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

• MulAction M α and its additive version AddAction G P are typeclasses used for actions of multiplicative and additive monoids and groups; they extend notation classes SMul and VAdd that are defined in Algebra.Group.Defs;
• DistribMulAction M A is a typeclass for an action of a multiplicative monoid on an additive monoid such that a • (b + c) = a • b + a • c and a • 0 = 0.

The hierarchy is extended further by Module, defined elsewhere.

Also provided are typeclasses regarding the interaction of different group actions,

• SMulCommClass M N α and its additive version VAddCommClass M N α;
• IsScalarTower M N α and its additive version VAddAssocClass M N α;
• IsCentralScalar M α and its additive version IsCentralVAdd M N α.

Notation

• a • b is used as notation for SMul.smul a b.
• a +ᵥ b is used as notation for VAdd.vadd a b.

Implementation details

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

Tags

group action

@[instance 910]

instance Mul.toSMul (α : Type u_9) [Mul α] : SMul α α

See also Monoid.toMulAction and MulZeroClass.toSMulWithZero.

Equations

• Mul.toSMul α = { smul := fun (x1 x2 : α) => x1 * x2 }

@[instance 910]

instance Add.toVAdd (α : Type u_9) [Add α] : VAdd α α

See also AddMonoid.toAddAction

Equations

• Add.toVAdd α = { vadd := fun (x1 x2 : α) => x1 + x2 }

@[simp]

theorem smul_eq_mul (α : Type u_9) [Mul α] {a a' : α} : a • a' = a * a'

@[simp]

theorem vadd_eq_add (α : Type u_9) [Add α] {a a' : α} : a +ᵥ a' = a + a'

class AddAction (G : Type u_9) (P : Type u_10) [AddMonoid G] extends VAdd G P : Type (max u_10 u_9)

Type class for additive monoid actions.

• vadd : G → P → P
• zero_vadd : ∀ (p : P), 0 +ᵥ p = p

  Zero is a neutral element for +ᵥ

• add_vadd : ∀ (g₁ g₂ : G) (p : P), g₁ + g₂ +ᵥ p = g₁ +ᵥ (g₂ +ᵥ p)

  Associativity of + and +ᵥ

class MulAction (α : Type u_9) (β : Type u_10) [Monoid α] extends SMul α β : Type (max u_10 u_9)

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

• smul : α → β → β
• one_smul : ∀ (b : β), 1 • b = b

  One is the neutral element for •

• mul_smul : ∀ (x y : α) (b : β), (x * y) • b = x • y • b

  Associativity of • and *

theorem MulAction.ext {α : Type u_9} {β : Type u_10} {inst✝ : Monoid α} {x y : MulAction α β} (smul : SMul.smul = SMul.smul) : x = y

theorem AddAction.ext {G : Type u_9} {P : Type u_10} {inst✝ : AddMonoid G} {x y : AddAction G P} (vadd : VAdd.vadd = VAdd.vadd) : x = y

Scalar tower and commuting actions

class VAddCommClass (M : Type u_9) (N : Type u_10) (α : Type u_11) [VAdd M α] [VAdd N α] : Prop

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

• vadd_comm : ∀ (m : M) (n : N) (a : α), m +ᵥ (n +ᵥ a) = n +ᵥ (m +ᵥ a)

  +ᵥ is left commutative

class SMulCommClass (M : Type u_9) (N : Type u_10) (α : Type u_11) [SMul M α] [SMul N α] : Prop

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

• smul_comm : ∀ (m : M) (n : N) (a : α), m • n • a = n • m • a

  • is left commutative

theorem SMulCommClass.symm (M : Type u_9) (N : Type u_10) (α : Type u_11) [SMul M α] [SMul N α] [SMulCommClass M N α] : SMulCommClass N M α

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 VAddCommClass.symm (M : Type u_9) (N : Type u_10) (α : Type u_11) [VAdd M α] [VAdd N α] [VAddCommClass M N α] : VAddCommClass N M α

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.

theorem Function.Injective.smulCommClass {M : Type u_1} {N : Type u_2} {α : Type u_5} {β : Type u_6} [SMul M α] [SMul N α] [SMul M β] [SMul N β] [SMulCommClass M N β] {f : α → β} (hf : Function.Injective f) (h₁ : ∀ (c : M) (x : α), f (c • x) = c • f x) (h₂ : ∀ (c : N) (x : α), f (c • x) = c • f x) : SMulCommClass M N α

theorem Function.Injective.vaddCommClass {M : Type u_1} {N : Type u_2} {α : Type u_5} {β : Type u_6} [VAdd M α] [VAdd N α] [VAdd M β] [VAdd N β] [VAddCommClass M N β] {f : α → β} (hf : Function.Injective f) (h₁ : ∀ (c : M) (x : α), f (c +ᵥ x) = c +ᵥ f x) (h₂ : ∀ (c : N) (x : α), f (c +ᵥ x) = c +ᵥ f x) : VAddCommClass M N α

theorem Function.Surjective.smulCommClass {M : Type u_1} {N : Type u_2} {α : Type u_5} {β : Type u_6} [SMul M α] [SMul N α] [SMul M β] [SMul N β] [SMulCommClass M N α] {f : α → β} (hf : Function.Surjective f) (h₁ : ∀ (c : M) (x : α), f (c • x) = c • f x) (h₂ : ∀ (c : N) (x : α), f (c • x) = c • f x) : SMulCommClass M N β

theorem Function.Surjective.vaddCommClass {M : Type u_1} {N : Type u_2} {α : Type u_5} {β : Type u_6} [VAdd M α] [VAdd N α] [VAdd M β] [VAdd N β] [VAddCommClass M N α] {f : α → β} (hf : Function.Surjective f) (h₁ : ∀ (c : M) (x : α), f (c +ᵥ x) = c +ᵥ f x) (h₂ : ∀ (c : N) (x : α), f (c +ᵥ x) = c +ᵥ f x) : VAddCommClass M N β

instance smulCommClass_self (M : Type u_9) (α : Type u_10) [CommMonoid M] [MulAction M α] : SMulCommClass M M α

Equations

• ⋯ = ⋯

instance vaddCommClass_self (M : Type u_9) (α : Type u_10) [AddCommMonoid M] [AddAction M α] : VAddCommClass M M α

Equations

• ⋯ = ⋯

class VAddAssocClass (M : Type u_9) (N : Type u_10) (α : Type u_11) [VAdd M N] [VAdd N α] [VAdd M α] : Prop

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

• vadd_assoc : ∀ (x : M) (y : N) (z : α), x +ᵥ y +ᵥ z = x +ᵥ (y +ᵥ z)

  Associativity of +ᵥ

class IsScalarTower (M : Type u_9) (N : Type u_10) (α : Type u_11) [SMul M N] [SMul N α] [SMul M α] : Prop

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

• smul_assoc : ∀ (x : M) (y : N) (z : α), (x • y) • z = x • y • z

  Associativity of •

@[simp]

theorem smul_assoc {α : Type u_5} {M : Type u_9} {N : Type u_10} [SMul M N] [SMul N α] [SMul M α] [IsScalarTower M N α] (x : M) (y : N) (z : α) : (x • y) • z = x • y • z

@[simp]

theorem vadd_assoc {α : Type u_5} {M : Type u_9} {N : Type u_10} [VAdd M N] [VAdd N α] [VAdd M α] [VAddAssocClass M N α] (x : M) (y : N) (z : α) : x +ᵥ y +ᵥ z = x +ᵥ (y +ᵥ z)

instance Semigroup.isScalarTower {α : Type u_5} [Semigroup α] : IsScalarTower α α α

Equations

• ⋯ = ⋯

instance AddSemigroup.isScalarTower {α : Type u_5} [AddSemigroup α] : VAddAssocClass α α α

Equations

• ⋯ = ⋯

class IsCentralVAdd (M : Type u_9) (α : Type u_10) [VAdd M α] [VAdd Mᵃᵒᵖ α] : Prop

A typeclass indicating that the right (aka AddOpposite) 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 +ᵥ.

• op_vadd_eq_vadd : ∀ (m : M) (a : α), AddOpposite.op m +ᵥ a = m +ᵥ a

  The right and left actions of M on α are equal.

class IsCentralScalar (M : Type u_9) (α : Type u_10) [SMul M α] [SMul Mᵐᵒᵖ α] : Prop

A typeclass indicating that the right (aka MulOpposite) 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 •.

• op_smul_eq_smul : ∀ (m : M) (a : α), MulOpposite.op m • a = m • a

  The right and left actions of M on α are equal.

theorem IsCentralScalar.unop_smul_eq_smul {M : Type u_9} {α : Type u_10} [SMul M α] [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] (m : Mᵐᵒᵖ) (a : α) : MulOpposite.unop m • a = m • a

theorem IsCentralVAdd.unop_vadd_eq_vadd {M : Type u_9} {α : Type u_10} [VAdd M α] [VAdd Mᵃᵒᵖ α] [IsCentralVAdd M α] (m : Mᵃᵒᵖ) (a : α) : AddOpposite.unop m +ᵥ a = m +ᵥ a

@[instance 50]

instance SMulCommClass.op_left {M : Type u_1} {N : Type u_2} {α : Type u_5} [SMul M α] [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] [SMul N α] [SMulCommClass M N α] : SMulCommClass Mᵐᵒᵖ N α

Equations

• ⋯ = ⋯

@[instance 50]

instance VAddCommClass.op_left {M : Type u_1} {N : Type u_2} {α : Type u_5} [VAdd M α] [VAdd Mᵃᵒᵖ α] [IsCentralVAdd M α] [VAdd N α] [VAddCommClass M N α] : VAddCommClass Mᵃᵒᵖ N α

Equations

• ⋯ = ⋯

@[instance 50]

instance SMulCommClass.op_right {M : Type u_1} {N : Type u_2} {α : Type u_5} [SMul M α] [SMul N α] [SMul Nᵐᵒᵖ α] [IsCentralScalar N α] [SMulCommClass M N α] : SMulCommClass M Nᵐᵒᵖ α

Equations

• ⋯ = ⋯

@[instance 50]

instance VAddCommClass.op_right {M : Type u_1} {N : Type u_2} {α : Type u_5} [VAdd M α] [VAdd N α] [VAdd Nᵃᵒᵖ α] [IsCentralVAdd N α] [VAddCommClass M N α] : VAddCommClass M Nᵃᵒᵖ α

Equations

• ⋯ = ⋯

@[instance 50]

instance IsScalarTower.op_left {M : Type u_1} {N : Type u_2} {α : Type u_5} [SMul M α] [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] [SMul M N] [SMul Mᵐᵒᵖ N] [IsCentralScalar M N] [SMul N α] [IsScalarTower M N α] : IsScalarTower Mᵐᵒᵖ N α

Equations

• ⋯ = ⋯

@[instance 50]

instance VAddAssocClass.op_left {M : Type u_1} {N : Type u_2} {α : Type u_5} [VAdd M α] [VAdd Mᵃᵒᵖ α] [IsCentralVAdd M α] [VAdd M N] [VAdd Mᵃᵒᵖ N] [IsCentralVAdd M N] [VAdd N α] [VAddAssocClass M N α] : VAddAssocClass Mᵃᵒᵖ N α

Equations

• ⋯ = ⋯

@[instance 50]

instance IsScalarTower.op_right {M : Type u_1} {N : Type u_2} {α : Type u_5} [SMul M α] [SMul M N] [SMul N α] [SMul Nᵐᵒᵖ α] [IsCentralScalar N α] [IsScalarTower M N α] : IsScalarTower M Nᵐᵒᵖ α

Equations

• ⋯ = ⋯

@[instance 50]

instance VAddAssocClass.op_right {M : Type u_1} {N : Type u_2} {α : Type u_5} [VAdd M α] [VAdd M N] [VAdd N α] [VAdd Nᵃᵒᵖ α] [IsCentralVAdd N α] [VAddAssocClass M N α] : VAddAssocClass M Nᵃᵒᵖ α

Equations

• ⋯ = ⋯

def SMul.comp.smul {M : Type u_1} {N : Type u_2} {α : Type u_5} [SMul M α] (g : N → M) (n : N) (a : α) : α

Auxiliary definition for SMul.comp, MulAction.compHom, DistribMulAction.compHom, Module.compHom, etc.

Equations

• SMul.comp.smul g n a = g n • a

def VAdd.comp.vadd {M : Type u_1} {N : Type u_2} {α : Type u_5} [VAdd M α] (g : N → M) (n : N) (a : α) : α

Auxiliary definition for VAdd.comp, AddAction.compHom, etc.

Equations

• VAdd.comp.vadd g n a = g n +ᵥ a

@[reducible, inline]

abbrev SMul.comp {M : Type u_1} {N : Type u_2} (α : Type u_5) [SMul M α] (g : N → M) : SMul N α

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

Equations

• SMul.comp α g = { smul := SMul.comp.smul g }

@[reducible, inline]

abbrev VAdd.comp {M : Type u_1} {N : Type u_2} (α : Type u_5) [VAdd M α] (g : N → M) : VAdd N α

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

Equations

• VAdd.comp α g = { vadd := VAdd.comp.vadd g }

theorem SMul.comp.isScalarTower {M : Type u_1} {N : Type u_2} {α : Type u_5} {β : Type u_6} [SMul M α] [SMul M β] [SMul α β] [IsScalarTower M α β] (g : N → M) : IsScalarTower N α β

Given a tower of scalar actions M → α → β, if we use SMul.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 SMul arguments are still metavariables.

theorem VAdd.comp.isScalarTower {M : Type u_1} {N : Type u_2} {α : Type u_5} {β : Type u_6} [VAdd M α] [VAdd M β] [VAdd α β] [VAddAssocClass M α β] (g : N → M) : VAddAssocClass N α β

Given a tower of additive actions M → α → β, if we use SMul.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 SMul arguments are still metavariables.

theorem SMul.comp.smulCommClass {M : Type u_1} {N : Type u_2} {α : Type u_5} {β : Type u_6} [SMul M α] [SMul β α] [SMulCommClass M β α] (g : N → M) : SMulCommClass N β α

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

theorem VAdd.comp.vaddCommClass {M : Type u_1} {N : Type u_2} {α : Type u_5} {β : Type u_6} [VAdd M α] [VAdd β α] [VAddCommClass M β α] (g : N → M) : VAddCommClass N β α

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

theorem SMul.comp.smulCommClass' {M : Type u_1} {N : Type u_2} {α : Type u_5} {β : Type u_6} [SMul M α] [SMul β α] [SMulCommClass β M α] (g : N → M) : SMulCommClass β N α

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

theorem VAdd.comp.vaddCommClass' {M : Type u_1} {N : Type u_2} {α : Type u_5} {β : Type u_6} [VAdd M α] [VAdd β α] [VAddCommClass β M α] (g : N → M) : VAddCommClass β N α

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

theorem mul_smul_comm {α : Type u_5} {β : Type u_6} [Mul β] [SMul α β] [SMulCommClass α β β] (s : α) (x y : β) : x * s • y = s • (x * y)

Note that the SMulCommClass α β β typeclass argument is usually satisfied by Algebra α β.

theorem add_vadd_comm {α : Type u_5} {β : Type u_6} [Add β] [VAdd α β] [VAddCommClass α β β] (s : α) (x y : β) : x + (s +ᵥ y) = s +ᵥ (x + y)

theorem smul_mul_assoc {α : Type u_5} {β : Type u_6} [Mul β] [SMul α β] [IsScalarTower α β β] (r : α) (x y : β) : r • x * y = r • (x * y)

Note that the IsScalarTower α β β typeclass argument is usually satisfied by Algebra α β.

theorem vadd_add_assoc {α : Type u_5} {β : Type u_6} [Add β] [VAdd α β] [VAddAssocClass α β β] (r : α) (x y : β) : r +ᵥ x + y = r +ᵥ (x + y)

theorem smul_div_assoc {α : Type u_5} {β : Type u_6} [DivInvMonoid β] [SMul α β] [IsScalarTower α β β] (r : α) (x y : β) : r • x / y = r • (x / y)

Note that the IsScalarTower α β β typeclass argument is usually satisfied by Algebra α β.

theorem vadd_sub_assoc {α : Type u_5} {β : Type u_6} [SubNegMonoid β] [VAdd α β] [VAddAssocClass α β β] (r : α) (x y : β) : r +ᵥ x - y = r +ᵥ (x - y)

theorem smul_smul_smul_comm {α : Type u_5} {β : Type u_6} {γ : Type u_7} {δ : Type u_8} [SMul α β] [SMul α γ] [SMul β δ] [SMul α δ] [SMul γ δ] [IsScalarTower α β δ] [IsScalarTower α γ δ] [SMulCommClass β γ δ] (a : α) (b : β) (c : γ) (d : δ) : (a • b) • c • d = (a • c) • b • d

theorem vadd_vadd_vadd_comm {α : Type u_5} {β : Type u_6} {γ : Type u_7} {δ : Type u_8} [VAdd α β] [VAdd α γ] [VAdd β δ] [VAdd α δ] [VAdd γ δ] [VAddAssocClass α β δ] [VAddAssocClass α γ δ] [VAddCommClass β γ δ] (a : α) (b : β) (c : γ) (d : δ) : a +ᵥ b +ᵥ (c +ᵥ d) = a +ᵥ c +ᵥ (b +ᵥ d)

theorem smul_mul_smul_comm {α : Type u_5} {β : Type u_6} [Mul α] [Mul β] [SMul α β] [IsScalarTower α β β] [IsScalarTower α α β] [SMulCommClass α β β] (a : α) (b : β) (c : α) (d : β) : a • b * c • d = (a * c) • (b * d)

Note that the IsScalarTower α β β and SMulCommClass α β β typeclass arguments are usually satisfied by Algebra α β.

theorem vadd_add_vadd_comm {α : Type u_5} {β : Type u_6} [Add α] [Add β] [VAdd α β] [VAddAssocClass α β β] [VAddAssocClass α α β] [VAddCommClass α β β] (a : α) (b : β) (c : α) (d : β) : a +ᵥ b + (c +ᵥ d) = a + c +ᵥ (b + d)

@[deprecated]

theorem smul_mul_smul {α : Type u_5} {β : Type u_6} [Mul α] [Mul β] [SMul α β] [IsScalarTower α β β] [IsScalarTower α α β] [SMulCommClass α β β] (a : α) (b : β) (c : α) (d : β) : a • b * c • d = (a * c) • (b * d)

Alias of smul_mul_smul_comm.

---

Note that the IsScalarTower α β β and SMulCommClass α β β typeclass arguments are usually satisfied by Algebra α β.

@[deprecated]

theorem vadd_add_vadd {α : Type u_5} {β : Type u_6} [Add α] [Add β] [VAdd α β] [VAddAssocClass α β β] [VAddAssocClass α α β] [VAddCommClass α β β] (a : α) (b : β) (c : α) (d : β) : a +ᵥ b + (c +ᵥ d) = a + c +ᵥ (b + d)

theorem mul_smul_mul_comm {α : Type u_5} {β : Type u_6} [Mul α] [Mul β] [SMul α β] [IsScalarTower α β β] [IsScalarTower α α β] [SMulCommClass α β β] (a b : α) (c d : β) : (a * b) • (c * d) = a • c * b • d

Note that the IsScalarTower α β β and SMulCommClass α β β typeclass arguments are usually satisfied by Algebra α β.

theorem add_vadd_add_comm {α : Type u_5} {β : Type u_6} [Add α] [Add β] [VAdd α β] [VAddAssocClass α β β] [VAddAssocClass α α β] [VAddCommClass α β β] (a b : α) (c d : β) : a + b +ᵥ (c + d) = a +ᵥ c + (b +ᵥ d)

theorem Commute.smul_right {M : Type u_1} {α : Type u_5} [SMul M α] [Mul α] [SMulCommClass M α α] [IsScalarTower M α α] {a b : α} (h : Commute a b) (r : M) : Commute a (r • b)

theorem AddCommute.vadd_right {M : Type u_1} {α : Type u_5} [VAdd M α] [Add α] [VAddCommClass M α α] [VAddAssocClass M α α] {a b : α} (h : AddCommute a b) (r : M) : AddCommute a (r +ᵥ b)

theorem Commute.smul_left {M : Type u_1} {α : Type u_5} [SMul M α] [Mul α] [SMulCommClass M α α] [IsScalarTower M α α] {a b : α} (h : Commute a b) (r : M) : Commute (r • a) b

theorem AddCommute.vadd_left {M : Type u_1} {α : Type u_5} [VAdd M α] [Add α] [VAddCommClass M α α] [VAddAssocClass M α α] {a b : α} (h : AddCommute a b) (r : M) : AddCommute (r +ᵥ a) b

theorem smul_smul {M : Type u_1} {α : Type u_5} [Monoid M] [MulAction M α] (a₁ a₂ : M) (b : α) : a₁ • a₂ • b = (a₁ * a₂) • b

theorem vadd_vadd {M : Type u_1} {α : Type u_5} [AddMonoid M] [AddAction M α] (a₁ a₂ : M) (b : α) : a₁ +ᵥ (a₂ +ᵥ b) = a₁ + a₂ +ᵥ b

@[simp]

theorem one_smul (M : Type u_1) {α : Type u_5} [Monoid M] [MulAction M α] (b : α) : 1 • b = b

@[simp]

theorem zero_vadd (M : Type u_1) {α : Type u_5} [AddMonoid M] [AddAction M α] (b : α) : 0 +ᵥ b = b

theorem one_smul_eq_id (M : Type u_1) {α : Type u_5} [Monoid M] [MulAction M α] : (fun (x : α) => 1 • x) = id

SMul version of one_mul_eq_id

theorem zero_vadd_eq_id (M : Type u_1) {α : Type u_5} [AddMonoid M] [AddAction M α] : (fun (x : α) => 0 +ᵥ x) = id

VAdd version of zero_add_eq_id

theorem comp_smul_left (M : Type u_1) {α : Type u_5} [Monoid M] [MulAction M α] (a₁ a₂ : M) : ((fun (x : α) => a₁ • x) ∘ fun (x : α) => a₂ • x) = fun (x : α) => (a₁ * a₂) • x

SMul version of comp_mul_left

theorem comp_vadd_left (M : Type u_1) {α : Type u_5} [AddMonoid M] [AddAction M α] (a₁ a₂ : M) : ((fun (x : α) => a₁ +ᵥ x) ∘ fun (x : α) => a₂ +ᵥ x) = fun (x : α) => a₁ + a₂ +ᵥ x

VAdd version of comp_add_left

@[reducible, inline]

abbrev Function.Injective.mulAction {M : Type u_1} {α : Type u_5} {β : Type u_6} [Monoid M] [MulAction M α] [SMul M β] (f : β → α) (hf : Function.Injective f) (smul : ∀ (c : M) (x : β), f (c • x) = c • f x) : MulAction M β

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

Equations

• Function.Injective.mulAction f hf smul = MulAction.mk ⋯ ⋯

@[reducible, inline]

abbrev Function.Injective.addAction {M : Type u_1} {α : Type u_5} {β : Type u_6} [AddMonoid M] [AddAction M α] [VAdd M β] (f : β → α) (hf : Function.Injective f) (smul : ∀ (c : M) (x : β), f (c +ᵥ x) = c +ᵥ f x) : AddAction M β

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

Equations

• Function.Injective.addAction f hf smul = AddAction.mk ⋯ ⋯

@[reducible, inline]

abbrev Function.Surjective.mulAction {M : Type u_1} {α : Type u_5} {β : Type u_6} [Monoid M] [MulAction M α] [SMul M β] (f : α → β) (hf : Function.Surjective f) (smul : ∀ (c : M) (x : α), f (c • x) = c • f x) : MulAction M β

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

Equations

• Function.Surjective.mulAction f hf smul = MulAction.mk ⋯ ⋯

@[reducible, inline]

abbrev Function.Surjective.addAction {M : Type u_1} {α : Type u_5} {β : Type u_6} [AddMonoid M] [AddAction M α] [VAdd M β] (f : α → β) (hf : Function.Surjective f) (smul : ∀ (c : M) (x : α), f (c +ᵥ x) = c +ᵥ f x) : AddAction M β

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

Equations

• Function.Surjective.addAction f hf smul = AddAction.mk ⋯ ⋯

@[instance 910]

instance Monoid.toMulAction (M : Type u_1) [Monoid M] : MulAction M M

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

This is promoted to a module by Semiring.toModule.

Equations

• Monoid.toMulAction M = MulAction.mk ⋯ ⋯

@[instance 910]

instance AddMonoid.toAddAction (M : Type u_1) [AddMonoid M] : AddAction M M

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

This is promoted to an AddTorsor by addGroup_is_addTorsor.

Equations

• AddMonoid.toAddAction M = AddAction.mk ⋯ ⋯

instance IsScalarTower.left (M : Type u_1) {α : Type u_5} [Monoid M] [MulAction M α] : IsScalarTower M M α

Equations

• ⋯ = ⋯

instance VAddAssocClass.left (M : Type u_1) {α : Type u_5} [AddMonoid M] [AddAction M α] : VAddAssocClass M M α

Equations

• ⋯ = ⋯

theorem smul_pow {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] [MulAction M N] [IsScalarTower M N N] [SMulCommClass M N N] (r : M) (x : N) (n : ℕ) : (r • x) ^ n = r ^ n • x ^ n

@[simp]

theorem inv_smul_smul {G : Type u_3} {α : Type u_5} [Group G] [MulAction G α] (g : G) (a : α) : g⁻¹ • g • a = a

@[simp]

theorem neg_vadd_vadd {G : Type u_3} {α : Type u_5} [AddGroup G] [AddAction G α] (g : G) (a : α) : -g +ᵥ (g +ᵥ a) = a

@[simp]

theorem smul_inv_smul {G : Type u_3} {α : Type u_5} [Group G] [MulAction G α] (g : G) (a : α) : g • g⁻¹ • a = a

@[simp]

theorem vadd_neg_vadd {G : Type u_3} {α : Type u_5} [AddGroup G] [AddAction G α] (g : G) (a : α) : g +ᵥ (-g +ᵥ a) = a

theorem inv_smul_eq_iff {G : Type u_3} {α : Type u_5} [Group G] [MulAction G α] {g : G} {a b : α} : g⁻¹ • a = b ↔ a = g • b

theorem neg_vadd_eq_iff {G : Type u_3} {α : Type u_5} [AddGroup G] [AddAction G α] {g : G} {a b : α} : -g +ᵥ a = b ↔ a = g +ᵥ b

theorem eq_inv_smul_iff {G : Type u_3} {α : Type u_5} [Group G] [MulAction G α] {g : G} {a b : α} : a = g⁻¹ • b ↔ g • a = b

theorem eq_neg_vadd_iff {G : Type u_3} {α : Type u_5} [AddGroup G] [AddAction G α] {g : G} {a b : α} : a = -g +ᵥ b ↔ g +ᵥ a = b

@[simp]

theorem Commute.smul_right_iff {G : Type u_3} {H : Type u_4} [Group G] {g : G} [Mul H] [MulAction G H] [SMulCommClass G H H] [IsScalarTower G H H] {a b : H} : Commute a (g • b) ↔ Commute a b

@[simp]

theorem Commute.smul_left_iff {G : Type u_3} {H : Type u_4} [Group G] {g : G} [Mul H] [MulAction G H] [SMulCommClass G H H] [IsScalarTower G H H] {a b : H} : Commute (g • a) b ↔ Commute a b

theorem smul_inv {G : Type u_3} {H : Type u_4} [Group G] [Group H] [MulAction G H] [SMulCommClass G H H] [IsScalarTower G H H] (g : G) (a : H) : (g • a)⁻¹ = g⁻¹ • a⁻¹

theorem smul_zpow {G : Type u_3} {H : Type u_4} [Group G] [Group H] [MulAction G H] [SMulCommClass G H H] [IsScalarTower G H H] (g : G) (a : H) (n : ℤ) : (g • a) ^ n = g ^ n • a ^ n

theorem SMulCommClass.of_commMonoid (A : Type u_9) (B : Type u_10) (G : Type u_11) [CommMonoid G] [SMul A G] [SMul B G] [IsScalarTower A G G] [IsScalarTower B G G] : SMulCommClass A B G

def MulAction.toFun (M : Type u_1) (α : Type u_5) [Monoid M] [MulAction M α] : α ↪ M → α

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

Equations

• MulAction.toFun M α = { toFun := fun (y : α) (x : M) => x • y, inj' := ⋯ }

def AddAction.toFun (M : Type u_1) (α : Type u_5) [AddMonoid M] [AddAction M α] : α ↪ M → α

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

Equations

• AddAction.toFun M α = { toFun := fun (y : α) (x : M) => x +ᵥ y, inj' := ⋯ }

@[simp]

theorem MulAction.toFun_apply {M : Type u_1} {α : Type u_5} [Monoid M] [MulAction M α] (x : M) (y : α) : (MulAction.toFun M α) y x = x • y

@[simp]

theorem AddAction.toFun_apply {M : Type u_1} {α : Type u_5} [AddMonoid M] [AddAction M α] (x : M) (y : α) : (AddAction.toFun M α) y x = x +ᵥ y

theorem smul_one_smul {α : Type u_5} {M : Type u_9} (N : Type u_10) [Monoid N] [SMul M N] [MulAction N α] [SMul M α] [IsScalarTower M N α] (x : M) (y : α) : (x • 1) • y = x • y

theorem vadd_zero_vadd {α : Type u_5} {M : Type u_9} (N : Type u_10) [AddMonoid N] [VAdd M N] [AddAction N α] [VAdd M α] [VAddAssocClass M N α] (x : M) (y : α) : x +ᵥ 0 +ᵥ y = x +ᵥ y

@[simp]

theorem smul_one_mul {M : Type u_9} {N : Type u_10} [MulOneClass N] [SMul M N] [IsScalarTower M N N] (x : M) (y : N) : x • 1 * y = x • y

@[simp]

theorem vadd_zero_add {M : Type u_9} {N : Type u_10} [AddZeroClass N] [VAdd M N] [VAddAssocClass M N N] (x : M) (y : N) : x +ᵥ 0 + y = x +ᵥ y

@[simp]

theorem mul_smul_one {M : Type u_9} {N : Type u_10} [MulOneClass N] [SMul M N] [SMulCommClass M N N] (x : M) (y : N) : y * x • 1 = x • y

@[simp]

theorem add_vadd_zero {M : Type u_9} {N : Type u_10} [AddZeroClass N] [VAdd M N] [VAddCommClass M N N] (x : M) (y : N) : y + (x +ᵥ 0) = x +ᵥ y

theorem IsScalarTower.of_smul_one_mul {M : Type u_9} {N : Type u_10} [Monoid N] [SMul M N] (h : ∀ (x : M) (y : N), x • 1 * y = x • y) : IsScalarTower M N N

theorem VAddAssocClass.of_vadd_zero_add {M : Type u_9} {N : Type u_10} [AddMonoid N] [VAdd M N] (h : ∀ (x : M) (y : N), x +ᵥ 0 + y = x +ᵥ y) : VAddAssocClass M N N

theorem SMulCommClass.of_mul_smul_one {M : Type u_9} {N : Type u_10} [Monoid N] [SMul M N] (H : ∀ (x : M) (y : N), y * x • 1 = x • y) : SMulCommClass M N N

theorem VAddCommClass.of_add_vadd_zero {M : Type u_9} {N : Type u_10} [AddMonoid N] [VAdd M N] (H : ∀ (x : M) (y : N), y + (x +ᵥ 0) = x +ᵥ y) : VAddCommClass M N N