group_theory.group_action.defs

Frequently, we find ourselves wanting to express a bilinear map M →ₗ[R] N →ₗ[R] P or an equivalence between maps (M →ₗ[R] N) ≃ₗ[R] (M' →ₗ[R] N') where the maps have an associated ring R. Unfortunately, using definitions like these requires that R satisfy comm_semiring R, and not just semiring R. Using M →ₗ[R] N →+ P and (M →ₗ[R] N) ≃+ (M' →ₗ[R] N') avoids this problem, but throws away structure that is useful for when we do have a commutative (semi)ring.

To avoid making this compromise, we instead state these definitions as M →ₗ[R] N →ₗ[S] P or (M →ₗ[R] N) ≃ₗ[S] (M' →ₗ[R] N') and require smul_comm_class S R on the appropriate modules. When the caller has comm_semiring R, they can set S = R and smul_comm_class_self will populate the instance. If the caller only has semiring R they can still set either R = ℕ or S = ℕ, and add_comm_monoid.nat_smul_comm_class or add_comm_monoid.nat_smul_comm_class' will populate the typeclass, which is still sufficient to recover a ≃+ or →+ structure.

An example of where this is used is linear_map.prod_equiv.

source

theorem smul_comm_class.symm (M : Type u_1) (N : Type u_2) (α : Type u_3) [has_smul M α] [has_smul N α] [smul_comm_class M N α] :

smul_comm_class 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.

source

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 α] :

vadd_comm_class 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.

source

@[protected, instance]

def vadd_comm_class_self (M : Type u_1) (α : Type u_2) [add_comm_monoid M] [add_action M α] :

vadd_comm_class M M α

source

@[protected, instance]

def smul_comm_class_self (M : Type u_1) (α : Type u_2) [comm_monoid M] [mul_action M α] :

smul_comm_class M M α

source

@[class]

structure vadd_assoc_class (M : Type u_10) (N : Type u_11) (α : Type u_12) [has_vadd M N] [has_vadd N α] [has_vadd M α] :

Prop

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

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

Instances of this typeclass

source

@[class]

structure is_scalar_tower (M : Type u_10) (N : Type u_11) (α : Type u_12) [has_smul M N] [has_smul N α] [has_smul 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

source

@[simp]

theorem vadd_assoc {α : Type u_6} {M : Type u_1} {N : Type u_2} [has_vadd M N] [has_vadd N α] [has_vadd M α] [vadd_assoc_class M N α] (x : M) (y : N) (z : α) :

x +ᵥ y +ᵥ z = x +ᵥ (y +ᵥ z)

source

@[simp]

theorem smul_assoc {α : Type u_6} {M : Type u_1} {N : Type u_2} [has_smul M N] [has_smul N α] [has_smul M α] [is_scalar_tower M N α] (x : M) (y : N) (z : α) :

(x • y) • z = x • y • z

source

@[protected, instance]

def semigroup.is_scalar_tower {α : Type u_6} [semigroup α] :

is_scalar_tower α α α

source

@[protected, instance]

def add_semigroup.vadd_assoc_class {α : Type u_6} [add_semigroup α] :

vadd_assoc_class α α α

source

@[class]

structure is_central_vadd (M : Type u_10) (α : Type u_11) [has_vadd M α] [has_vadd Mᵃᵒᵖ α] :

Prop

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

A typeclass indicating that the right (aka add_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

source

@[class]

structure is_central_scalar (M : Type u_10) (α : Type u_11) [has_smul M α] [has_smul Mᵐᵒᵖ α] :

Prop

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

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

source

theorem is_central_scalar.unop_smul_eq_smul {M : Type u_1} {α : Type u_2} [has_smul M α] [has_smul Mᵐᵒᵖ α] [is_central_scalar M α] (m : Mᵐᵒᵖ) (a : α) :

mul_opposite.unop m • a = m • a

source

theorem is_central_vadd.unop_vadd_eq_vadd {M : Type u_1} {α : Type u_2} [has_vadd M α] [has_vadd Mᵃᵒᵖ α] [is_central_vadd M α] (m : Mᵃᵒᵖ) (a : α) :

add_opposite.unop m +ᵥ a = m +ᵥ a

source

@[protected, instance]

def smul_comm_class.op_left {M : Type u_1} {N : Type u_2} {α : Type u_6} [has_smul M α] [has_smul Mᵐᵒᵖ α] [is_central_scalar M α] [has_smul N α] [smul_comm_class M N α] :

smul_comm_class Mᵐᵒᵖ N α

source

@[protected, instance]

def vadd_comm_class.op_left {M : Type u_1} {N : Type u_2} {α : Type u_6} [has_vadd M α] [has_vadd Mᵃᵒᵖ α] [is_central_vadd M α] [has_vadd N α] [vadd_comm_class M N α] :

vadd_comm_class Mᵃᵒᵖ N α

source

@[protected, instance]

def smul_comm_class.op_right {M : Type u_1} {N : Type u_2} {α : Type u_6} [has_smul M α] [has_smul N α] [has_smul Nᵐᵒᵖ α] [is_central_scalar N α] [smul_comm_class M N α] :

smul_comm_class M Nᵐᵒᵖ α

source

@[protected, instance]

def vadd_comm_class.op_right {M : Type u_1} {N : Type u_2} {α : Type u_6} [has_vadd M α] [has_vadd N α] [has_vadd Nᵃᵒᵖ α] [is_central_vadd N α] [vadd_comm_class M N α] :

vadd_comm_class M Nᵃᵒᵖ α

source

@[protected, instance]

def is_scalar_tower.op_left {M : Type u_1} {N : Type u_2} {α : Type u_6} [has_smul M α] [has_smul Mᵐᵒᵖ α] [is_central_scalar M α] [has_smul M N] [has_smul Mᵐᵒᵖ N] [is_central_scalar M N] [has_smul N α] [is_scalar_tower M N α] :

is_scalar_tower Mᵐᵒᵖ N α

source

@[protected, instance]

def vadd_assoc_class.op_left {M : Type u_1} {N : Type u_2} {α : Type u_6} [has_vadd M α] [has_vadd Mᵃᵒᵖ α] [is_central_vadd M α] [has_vadd M N] [has_vadd Mᵃᵒᵖ N] [is_central_vadd M N] [has_vadd N α] [vadd_assoc_class M N α] :

vadd_assoc_class Mᵃᵒᵖ N α

source

@[protected, instance]

def is_scalar_tower.op_right {M : Type u_1} {N : Type u_2} {α : Type u_6} [has_smul M α] [has_smul M N] [has_smul N α] [has_smul Nᵐᵒᵖ α] [is_central_scalar N α] [is_scalar_tower M N α] :

is_scalar_tower M Nᵐᵒᵖ α

source

@[protected, instance]

def vadd_assoc_class.op_right {M : Type u_1} {N : Type u_2} {α : Type u_6} [has_vadd M α] [has_vadd M N] [has_vadd N α] [has_vadd Nᵃᵒᵖ α] [is_central_vadd N α] [vadd_assoc_class M N α] :

vadd_assoc_class M Nᵃᵒᵖ α

source

@[simp]

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

α

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

Equations

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

source

@[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

has_vadd.comp.vadd g n a = g n +ᵥ a

source

@[reducible]

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

has_smul N α

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_smul.comp.smul to prevent typeclass inference unfolding too far.

Equations

has_smul.comp α g = {smul := has_smul.comp.smul g}

source

@[reducible]

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

has_vadd N α

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

Equations

has_vadd.comp α g = {vadd := has_vadd.comp.vadd g}

source

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

is_scalar_tower N α β

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

source

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

vadd_assoc_class N α β

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

source

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

smul_comm_class N β α

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

source

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

vadd_comm_class N β α

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

source

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

vadd_comm_class β N α

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

source

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

smul_comm_class β N α

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

source

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)

source

@[nolint]

theorem mul_smul_comm {α : Type u_6} {β : Type u_7} [has_mul β] [has_smul α β] [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 α β.

source

@[nolint]

theorem smul_mul_assoc {α : Type u_6} {β : Type u_7} [has_mul β] [has_smul α β] [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 α β.

source

theorem vadd_add_assoc {α : Type u_6} {β : Type u_7} [has_add β] [has_vadd α β] [vadd_assoc_class α β β] (r : α) (x y : β) :

r +ᵥ x + y = r +ᵥ (x + y)

source

theorem smul_smul_smul_comm {α : Type u_6} {β : Type u_7} {γ : Type u_8} {δ : Type u_9} [has_smul α β] [has_smul α γ] [has_smul β δ] [has_smul α δ] [has_smul γ δ] [is_scalar_tower α β δ] [is_scalar_tower α γ δ] [smul_comm_class β γ δ] (a : α) (b : β) (c : γ) (d : δ) :

(a • b) • c • d = (a • c) • b • d

source

theorem vadd_vadd_vadd_comm {α : Type u_6} {β : Type u_7} {γ : Type u_8} {δ : Type u_9} [has_vadd α β] [has_vadd α γ] [has_vadd β δ] [has_vadd α δ] [has_vadd γ δ] [vadd_assoc_class α β δ] [vadd_assoc_class α γ δ] [vadd_comm_class β γ δ] (a : α) (b : β) (c : γ) (d : δ) :

a +ᵥ b +ᵥ (c +ᵥ d) = a +ᵥ c +ᵥ (b +ᵥ d)

source

theorem add_commute.vadd_right {M : Type u_1} {α : Type u_6} [has_vadd M α] [has_add α] [vadd_comm_class M α α] [vadd_assoc_class M α α] {a b : α} (h : add_commute a b) (r : M) :

add_commute a (r +ᵥ b)

source

theorem commute.smul_right {M : Type u_1} {α : Type u_6} [has_smul M α] [has_mul α] [smul_comm_class M α α] [is_scalar_tower M α α] {a b : α} (h : commute a b) (r : M) :

commute a (r • b)

source

theorem commute.smul_left {M : Type u_1} {α : Type u_6} [has_smul M α] [has_mul α] [smul_comm_class M α α] [is_scalar_tower M α α] {a b : α} (h : commute a b) (r : M) :

commute (r • a) b

source

theorem add_commute.vadd_left {M : Type u_1} {α : Type u_6} [has_vadd M α] [has_add α] [vadd_comm_class M α α] [vadd_assoc_class M α α] {a b : α} (h : add_commute a b) (r : M) :

add_commute (r +ᵥ a) b

source

theorem ite_smul {M : Type u_1} {α : Type u_6} [has_smul M α] (p : Prop) [decidable p] (a₁ a₂ : M) (b : α) :

ite p a₁ a₂ • b = ite p (a₁ • b) (a₂ • b)

source

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)

source

theorem smul_ite {M : Type u_1} {α : Type u_6} [has_smul M α] (p : Prop) [decidable p] (a : M) (b₁ b₂ : α) :

a • ite p b₁ b₂ = ite p (a • b₁) (a • b₂)

source

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₂)

source

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

source

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

source

@[simp]

theorem one_smul (M : Type u_1) {α : Type u_6} [monoid M] [mul_action M α] (b : α) :

1 • b = b

source

@[simp]

theorem zero_vadd (M : Type u_1) {α : Type u_6} [add_monoid M] [add_action M α] (b : α) :

0 +ᵥ b = b

source

theorem one_smul_eq_id (M : Type u_1) {α : Type u_6} [monoid M] [mul_action M α] :

has_smul.smul 1 = id

has_smul version of one_mul_eq_id

source

theorem zero_vadd_eq_id (M : Type u_1) {α : Type u_6} [add_monoid M] [add_action M α] :

has_vadd.vadd 0 = id

has_vadd version of zero_add_eq_id

source

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

has_smul.smul a₁ ∘ has_smul.smul a₂ = has_smul.smul (a₁ * a₂)

has_smul version of comp_mul_left

source

theorem comp_vadd_left (M : Type u_1) {α : Type u_6} [add_monoid M] [add_action M α] (a₁ a₂ : M) :

has_vadd.vadd a₁ ∘ has_vadd.vadd a₂ = has_vadd.vadd (a₁ + a₂)

has_vadd version of comp_add_left

source

@[protected, reducible]

def function.injective.mul_action {M : Type u_1} {α : Type u_6} {β : Type u_7} [monoid M] [mul_action M α] [has_smul M β] (f : β → α) (hf : function.injective f) (smul : ∀ (c : M) (x : β), f (c • x) = c • f x) :

mul_action M β

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

Equations

function.injective.mul_action f hf smul = {to_has_smul := {smul := has_smul.smul _inst_3}, one_smul := _, mul_smul := _}

source

@[protected, reducible]

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) :

add_action M β

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

Equations

function.injective.add_action f hf smul = {to_has_vadd := {vadd := has_vadd.vadd _inst_3}, zero_vadd := _, add_vadd := _}

source

@[protected, reducible]

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) :

add_action M β

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

Equations

function.surjective.add_action f hf smul = {to_has_vadd := {vadd := has_vadd.vadd _inst_3}, zero_vadd := _, add_vadd := _}

source

@[protected, reducible]

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

mul_action M β

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

Equations

function.surjective.mul_action f hf smul = {to_has_smul := {smul := has_smul.smul _inst_3}, one_smul := _, mul_smul := _}

source

@[reducible]

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_smul S M] (f : R →* S) (hf : function.surjective ⇑f) (hsmul : ∀ (c : R) (x : M), ⇑f c • x = c • x) :

mul_action S M

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

Equations

function.surjective.mul_action_left f hf hsmul = {to_has_smul := {smul := has_smul.smul _inst_6}, one_smul := _, mul_smul := _}

source

@[reducible]

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) :

add_action S M

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

Equations

function.surjective.add_action_left f hf hsmul = {to_has_vadd := {vadd := has_vadd.vadd _inst_6}, zero_vadd := _, add_vadd := _}

source

@[protected, instance]

def monoid.to_mul_action (M : Type u_1) [monoid M] :

mul_action M M

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

This is promoted to a module by semiring.to_module.

Equations

monoid.to_mul_action M = {to_has_smul := {smul := has_mul.mul (mul_one_class.to_has_mul M)}, one_smul := _, mul_smul := _}

source

@[protected, instance]

def add_monoid.to_add_action (M : Type u_1) [add_monoid M] :

add_action M 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

add_monoid.to_add_action M = {to_has_vadd := {vadd := has_add.add (add_zero_class.to_has_add M)}, zero_vadd := _, add_vadd := _}

source

@[protected, instance]

def is_scalar_tower.left (M : Type u_1) {α : Type u_6} [monoid M] [mul_action M α] :

is_scalar_tower M M α

source

@[protected, instance]

def vadd_assoc_class.left (M : Type u_1) {α : Type u_6} [add_monoid M] [add_action M α] :

vadd_assoc_class M M α

source

theorem vadd_add_vadd {M : Type u_1} {α : Type u_6} [add_monoid M] [add_action M α] [has_add α] (r s : M) (x y : α) [vadd_assoc_class M α α] [vadd_comm_class M α α] :

r +ᵥ x + (s +ᵥ y) = r + s +ᵥ (x + y)

source

@[nolint]

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 α.

source

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

mul_action.to_fun M α = {to_fun := λ (y : α) (x : M), x • y, inj' := _}

source

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

add_action.to_fun M α = {to_fun := λ (y : α) (x : M), x +ᵥ y, inj' := _}

source

@[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

source

@[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

source

@[reducible]

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) :

mul_action N α

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

mul_action.comp_hom α g = {to_has_smul := {smul := has_smul.comp.smul ⇑g}, one_smul := _, mul_smul := _}

source

@[reducible]

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) :

add_action N α

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

add_action.comp_hom α g = {to_has_vadd := {vadd := has_vadd.comp.vadd ⇑g}, zero_vadd := _, add_vadd := _}

source

@[simp]

theorem vadd_zero_vadd {α : Type u_6} {M : Type u_1} (N : Type u_2) [add_monoid N] [has_vadd M N] [add_action N α] [has_vadd M α] [vadd_assoc_class M N α] (x : M) (y : α) :

x +ᵥ 0 +ᵥ y = x +ᵥ y

source

@[simp]

theorem smul_one_smul {α : Type u_6} {M : Type u_1} (N : Type u_2) [monoid N] [has_smul M N] [mul_action N α] [has_smul M α] [is_scalar_tower M N α] (x : M) (y : α) :

(x • 1) • y = x • y

source

@[simp]

theorem vadd_zero_add {M : Type u_1} {N : Type u_2} [add_zero_class N] [has_vadd M N] [vadd_assoc_class M N N] (x : M) (y : N) :

x +ᵥ 0 + y = x +ᵥ y

source

@[simp]

theorem smul_one_mul {M : Type u_1} {N : Type u_2} [mul_one_class N] [has_smul M N] [is_scalar_tower M N N] (x : M) (y : N) :

x • 1 * y = x • y

source

@[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

source

@[simp]

theorem mul_smul_one {M : Type u_1} {N : Type u_2} [mul_one_class N] [has_smul M N] [smul_comm_class M N N] (x : M) (y : N) :

y * x • 1 = x • y

source

theorem vadd_assoc_class.of_vadd_zero_add {M : Type u_1} {N : Type u_2} [add_monoid N] [has_vadd M N] (h : ∀ (x : M) (y : N), x +ᵥ 0 + y = x +ᵥ y) :

vadd_assoc_class M N N

source

theorem is_scalar_tower.of_smul_one_mul {M : Type u_1} {N : Type u_2} [monoid N] [has_smul M N] (h : ∀ (x : M) (y : N), x • 1 * y = x • y) :

is_scalar_tower M N N

source

theorem smul_comm_class.of_mul_smul_one {M : Type u_1} {N : Type u_2} [monoid N] [has_smul M N] (H : ∀ (x : M) (y : N), y * x • 1 = x • y) :

smul_comm_class M N N

source

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) :

vadd_comm_class M N N

source

@[simp]

theorem smul_one_hom_apply {M : Type u_1} {N : Type u_2} [monoid M] [monoid N] [mul_action M N] [is_scalar_tower M N N] (x : M) :

⇑smul_one_hom x = x • 1

source

@[simp]

theorem vadd_zero_hom_apply {M : Type u_1} {N : Type u_2} [add_monoid M] [add_monoid N] [add_action M N] [vadd_assoc_class M N N] (x : M) :

⇑vadd_zero_hom x = x +ᵥ 0

source

def vadd_zero_hom {M : Type u_1} {N : Type u_2} [add_monoid M] [add_monoid N] [add_action M N] [vadd_assoc_class M N N] :

M →+ N

If the additive action of M on N is compatible with addition on N, then λ x, x +ᵥ 0 is an additive monoid homomorphism from M to N.

Equations

vadd_zero_hom = {to_fun := λ (x : M), x +ᵥ 0, map_zero' := _, map_add' := _}

source

def smul_one_hom {M : Type u_1} {N : Type u_2} [monoid M] [monoid N] [mul_action M N] [is_scalar_tower M N N] :

M →* N

If the multiplicative action of M on N is compatible with multiplication on N, then λ x, x • 1 is a monoid homomorphism from M to N.

Equations

smul_one_hom = {to_fun := λ (x : M), x • 1, map_one' := _, map_mul' := _}

source

@[class]

structure smul_zero_class (M : Type u_10) (A : Type u_11) [has_zero A] :

Type (max u_10 u_11)

to_has_smul : has_smul M A
smul_zero : ∀ (a : M), a • 0 = 0

Typeclass for scalar multiplication that preserves 0 on the right.

Instances of this typeclass

Instances of other typeclasses for smul_zero_class

smul_zero_class.has_sizeof_inst

source

@[simp]

theorem smul_zero {M : Type u_1} {A : Type u_4} [has_zero A] [smul_zero_class M A] (a : M) :

a • 0 = 0

source

@[protected, reducible]

def function.injective.smul_zero_class {M : Type u_1} {A : Type u_4} {B : Type u_5} [has_zero A] [smul_zero_class M A] [has_zero B] [has_smul M B] (f : zero_hom B A) (hf : function.injective ⇑f) (smul : ∀ (c : M) (x : B), ⇑f (c • x) = c • ⇑f x) :

smul_zero_class M B

Pullback a zero-preserving scalar multiplication along an injective zero-preserving map. See note [reducible non-instances].

Equations

function.injective.smul_zero_class f hf smul = {to_has_smul := {smul := has_smul.smul _inst_4}, smul_zero := _}

source

@[protected, reducible]

def zero_hom.smul_zero_class {M : Type u_1} {A : Type u_4} {B : Type u_5} [has_zero A] [smul_zero_class M A] [has_zero B] [has_smul M B] (f : zero_hom A B) (smul : ∀ (c : M) (x : A), ⇑f (c • x) = c • ⇑f x) :

smul_zero_class M B

Pushforward a zero-preserving scalar multiplication along a zero-preserving map. See note [reducible non-instances].

Equations

f.smul_zero_class smul = {to_has_smul := {smul := has_smul.smul _inst_4}, smul_zero := _}

source

@[reducible]

def function.surjective.smul_zero_class_left {R : Type u_1} {S : Type u_2} {M : Type u_3} [has_zero M] [smul_zero_class R M] [has_smul S M] (f : R → S) (hf : function.surjective f) (hsmul : ∀ (c : R) (x : M), f c • x = c • x) :

smul_zero_class S M

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

Equations

function.surjective.smul_zero_class_left f hf hsmul = {to_has_smul := {smul := has_smul.smul _inst_5}, smul_zero := _}

source

@[reducible]

def smul_zero_class.comp_fun {M : Type u_1} {N : Type u_2} (A : Type u_4) [has_zero A] [smul_zero_class M A] (f : N → M) :

smul_zero_class N A

Compose a smul_zero_class with a function, with scalar multiplication f r' • m. See note [reducible non-instances].

Equations

smul_zero_class.comp_fun A f = {to_has_smul := {smul := has_smul.comp.smul f}, smul_zero := _}

source

def smul_zero_class.to_zero_hom {M : Type u_1} (A : Type u_4) [has_zero A] [smul_zero_class M A] (x : M) :

zero_hom A A

Each element of the scalars defines a zero-preserving map.

Equations

smul_zero_class.to_zero_hom A x = {to_fun := has_smul.smul x, map_zero' := _}

source

@[simp]

theorem smul_zero_class.to_zero_hom_apply {M : Type u_1} (A : Type u_4) [has_zero A] [smul_zero_class M A] (x : M) (ᾰ : A) :

⇑(smul_zero_class.to_zero_hom A x) ᾰ = x • ᾰ

source

theorem distrib_smul.ext {M : Type u_10} {A : Type u_11} {_inst_1 : add_zero_class A} (x y : distrib_smul M A) (h : distrib_smul.to_smul_zero_class = distrib_smul.to_smul_zero_class) :

x = y

source

@[ext, class]

structure distrib_smul (M : Type u_10) (A : Type u_11) [add_zero_class A] :

Type (max u_10 u_11)

to_smul_zero_class : smul_zero_class M A
smul_add : ∀ (a : M) (x y : A), a • (x + y) = a • x + a • y

Typeclass for scalar multiplication that preserves 0 and + on the right.

This is exactly distrib_mul_action without the mul_action part.

Instances of this typeclass

Instances of other typeclasses for distrib_smul

distrib_smul.has_sizeof_inst

source

theorem distrib_smul.ext_iff {M : Type u_10} {A : Type u_11} {_inst_1 : add_zero_class A} (x y : distrib_smul M A) :

x = y ↔ distrib_smul.to_smul_zero_class = distrib_smul.to_smul_zero_class

source

@[simp]

theorem smul_add {M : Type u_1} {A : Type u_4} [add_zero_class A] [distrib_smul M A] (a : M) (b₁ b₂ : A) :

a • (b₁ + b₂) = a • b₁ + a • b₂

source

@[protected, reducible]

def function.injective.distrib_smul {M : Type u_1} {A : Type u_4} {B : Type u_5} [add_zero_class A] [distrib_smul M A] [add_zero_class B] [has_smul M B] (f : B →+ A) (hf : function.injective ⇑f) (smul : ∀ (c : M) (x : B), ⇑f (c • x) = c • ⇑f x) :

distrib_smul M B

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

Equations

function.injective.distrib_smul f hf smul = {to_smul_zero_class := {to_has_smul := {smul := has_smul.smul _inst_4}, smul_zero := _}, smul_add := _}

source

@[protected, reducible]

def function.surjective.distrib_smul {M : Type u_1} {A : Type u_4} {B : Type u_5} [add_zero_class A] [distrib_smul M A] [add_zero_class B] [has_smul M B] (f : A →+ B) (hf : function.surjective ⇑f) (smul : ∀ (c : M) (x : A), ⇑f (c • x) = c • ⇑f x) :

distrib_smul M B

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

Equations

function.surjective.distrib_smul f hf smul = {to_smul_zero_class := {to_has_smul := {smul := has_smul.smul _inst_4}, smul_zero := _}, smul_add := _}

source

@[reducible]

def function.surjective.distrib_smul_left {R : Type u_1} {S : Type u_2} {M : Type u_3} [add_zero_class M] [distrib_smul R M] [has_smul S M] (f : R → S) (hf : function.surjective f) (hsmul : ∀ (c : R) (x : M), f c • x = c • x) :

distrib_smul S M

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

Equations

function.surjective.distrib_smul_left f hf hsmul = {to_smul_zero_class := {to_has_smul := {smul := has_smul.smul _inst_5}, smul_zero := _}, smul_add := _}

source

@[reducible]

def distrib_smul.comp_fun {M : Type u_1} {N : Type u_2} (A : Type u_4) [add_zero_class A] [distrib_smul M A] (f : N → M) :

distrib_smul N A

Compose a distrib_smul with a function, with scalar multiplication f r' • m. See note [reducible non-instances].

Equations

distrib_smul.comp_fun A f = {to_smul_zero_class := {to_has_smul := {smul := has_smul.comp.smul f}, smul_zero := _}, smul_add := _}

source

@[simp]

theorem distrib_smul.to_add_monoid_hom_apply {M : Type u_1} (A : Type u_4) [add_zero_class A] [distrib_smul M A] (x : M) (ᾰ : A) :

⇑(distrib_smul.to_add_monoid_hom A x) ᾰ = x • ᾰ

source

def distrib_smul.to_add_monoid_hom {M : Type u_1} (A : Type u_4) [add_zero_class A] [distrib_smul M A] (x : M) :

A →+ A

Each element of the scalars defines a additive monoid homomorphism.

Equations

distrib_smul.to_add_monoid_hom A x = {to_fun := has_smul.smul x, map_zero' := _, map_add' := _}

source

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

source

@[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_zero : ∀ (a : M), a • 0 = 0
smul_add : ∀ (a : M) (x y : A), a • (x + y) = a • x + a • y

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

source

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) :

x = y ↔ distrib_mul_action.to_mul_action = distrib_mul_action.to_mul_action

source

@[protected, instance]

def distrib_mul_action.to_distrib_smul {M : Type u_1} {A : Type u_4} [monoid M] [add_monoid A] [distrib_mul_action M A] :

distrib_smul M A

Equations

distrib_mul_action.to_distrib_smul = {to_smul_zero_class := {to_has_smul := mul_action.to_has_smul distrib_mul_action.to_mul_action, smul_zero := _}, smul_add := _}

source

@[protected, reducible]

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_smul M B] (f : B →+ A) (hf : function.injective ⇑f) (smul : ∀ (c : M) (x : B), ⇑f (c • x) = c • ⇑f x) :

distrib_mul_action M B

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

Equations

function.injective.distrib_mul_action f hf smul = {to_mul_action := {to_has_smul := {smul := has_smul.smul _inst_5}, one_smul := _, mul_smul := _}, smul_zero := _, smul_add := _}

source

@[protected, reducible]

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_smul M B] (f : A →+ B) (hf : function.surjective ⇑f) (smul : ∀ (c : M) (x : A), ⇑f (c • x) = c • ⇑f x) :

distrib_mul_action M B

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

Equations

function.surjective.distrib_mul_action f hf smul = {to_mul_action := {to_has_smul := {smul := has_smul.smul _inst_5}, one_smul := _, mul_smul := _}, smul_zero := _, smul_add := _}

source

@[reducible]

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_smul S M] (f : R →* S) (hf : function.surjective ⇑f) (hsmul : ∀ (c : R) (x : M), ⇑f c • x = c • x) :

distrib_mul_action S M

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

Equations

function.surjective.distrib_mul_action_left f hf hsmul = {to_mul_action := {to_has_smul := {smul := has_smul.smul _inst_8}, one_smul := _, mul_smul := _}, smul_zero := _, smul_add := _}

source

@[reducible]

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) :

distrib_mul_action N A

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

Equations

distrib_mul_action.comp_hom A f = {to_mul_action := {to_has_smul := {smul := has_smul.comp.smul ⇑f}, one_smul := _, mul_smul := _}, smul_zero := _, smul_add := _}

source

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

distrib_mul_action.to_add_monoid_hom A x = distrib_smul.to_add_monoid_hom A x

source

@[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) :

⇑(distrib_mul_action.to_add_monoid_hom A x) ᾰ = x • ᾰ

source

@[simp]

theorem distrib_mul_action.to_add_monoid_End_apply (M : Type u_1) (A : Type u_4) [monoid M] [add_monoid A] [distrib_mul_action M A] (x : M) :

⇑(distrib_mul_action.to_add_monoid_End M A) x = distrib_mul_action.to_add_monoid_hom A x

source

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] :

M →* add_monoid.End A

Each element of the monoid defines an additive monoid homomorphism.

Equations

distrib_mul_action.to_add_monoid_End M A = {to_fun := distrib_mul_action.to_add_monoid_hom A _inst_3, map_one' := _, map_mul' := _}

source

@[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] :

smul_comm_class ℕ M A

source

@[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] :

smul_comm_class M ℕ A

source

@[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] :

smul_comm_class ℤ M A

source

@[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] :

smul_comm_class M ℤ A

source

@[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)

source

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

source

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

source

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) :

x = y ↔ mul_distrib_mul_action.to_mul_action = mul_distrib_mul_action.to_mul_action

source

@[ext, class]

structure mul_distrib_mul_action (M : Type u_10) (A : Type u_11) [monoid M] [monoid A] :

Type (max u_10 u_11)

to_mul_action : mul_action M A
smul_mul : ∀ (r : M) (x y : A), r • (x * y) = r • x * r • y
smul_one : ∀ (r : M), r • 1 = 1

Typeclass for multiplicative actions on multiplicative structures. This generalizes conjugation actions.

Instances of this typeclass

Instances of other typeclasses for mul_distrib_mul_action

mul_distrib_mul_action.has_sizeof_inst

source

@[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₂

source

@[protected, reducible]

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_smul M B] (f : B →* A) (hf : function.injective ⇑f) (smul : ∀ (c : M) (x : B), ⇑f (c • x) = c • ⇑f x) :

mul_distrib_mul_action M B

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

Equations

function.injective.mul_distrib_mul_action f hf smul = {to_mul_action := {to_has_smul := {smul := has_smul.smul _inst_5}, one_smul := _, mul_smul := _}, smul_mul := _, smul_one := _}

source

@[protected, reducible]

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_smul M B] (f : A →* B) (hf : function.surjective ⇑f) (smul : ∀ (c : M) (x : A), ⇑f (c • x) = c • ⇑f x) :

mul_distrib_mul_action M B

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

Equations

function.surjective.mul_distrib_mul_action f hf smul = {to_mul_action := {to_has_smul := {smul := has_smul.smul _inst_5}, one_smul := _, mul_smul := _}, smul_mul := _, smul_one := _}

source

@[reducible]

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) :

mul_distrib_mul_action N A

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

Equations

mul_distrib_mul_action.comp_hom A f = {to_mul_action := {to_has_smul := {smul := has_smul.comp.smul ⇑f}, one_smul := _, mul_smul := _}, smul_mul := _, smul_one := _}

source

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

mul_distrib_mul_action.to_monoid_hom A r = {to_fun := has_smul.smul r, map_one' := _, map_mul' := _}

source

@[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) :

⇑(mul_distrib_mul_action.to_monoid_hom A r) x = r • x

source

@[simp]

theorem mul_distrib_mul_action.to_monoid_End_apply (M : Type u_1) (A : Type u_4) [monoid M] [monoid A] [mul_distrib_mul_action M A] (r : M) :

⇑(mul_distrib_mul_action.to_monoid_End M A) r = mul_distrib_mul_action.to_monoid_hom A r

source

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] :

M →* monoid.End A

Each element of the monoid defines a monoid homomorphism.

Equations

mul_distrib_mul_action.to_monoid_End M A = {to_fun := mul_distrib_mul_action.to_monoid_hom A _inst_3, map_one' := _, map_mul' := _}

source

@[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)⁻¹

source

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

source

@[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

function.End α = (α → α)

Instances for function.End

source

@[protected, instance]

def function.End.monoid (α : Type u_6) :

monoid (function.End α)

Equations

function.End.monoid α = {mul := function.comp α, mul_assoc := _, one := id α, one_mul := _, mul_one := _, npow := npow_rec (mul_one_class.to_has_mul (function.End α)), npow_zero' := _, npow_succ' := _}

source

@[protected, instance]

def function.End.inhabited (α : Type u_6) :

inhabited (function.End α)

Equations

function.End.inhabited α = {default := 1}

source

@[protected, instance]

def function.End.apply_mul_action {α : Type u_6} :

mul_action (function.End α) α

The tautological action by function.End α on α.

This is generalized to bundled endomorphisms by:

equiv.perm.apply_mul_action
add_monoid.End.apply_distrib_mul_action
add_aut.apply_distrib_mul_action
mul_aut.apply_mul_distrib_mul_action
ring_hom.apply_distrib_mul_action
linear_equiv.apply_distrib_mul_action
linear_map.apply_module
ring_hom.apply_mul_semiring_action
alg_equiv.apply_mul_semiring_action

Equations

function.End.apply_mul_action = {to_has_smul := {smul := λ (_x : function.End α) (_y : α), _x _y}, one_smul := _, mul_smul := _}

source

@[simp]

theorem function.End.smul_def {α : Type u_6} (f : function.End α) (a : α) :

f • a = f a

source

@[protected, instance]

def function.End.apply_has_faithful_smul {α : Type u_6} :

has_faithful_smul (function.End α) α

function.End.apply_mul_action is faithful.

source

@[protected, instance]

def add_monoid.End.apply_distrib_mul_action {α : Type u_6} [add_monoid α] :

distrib_mul_action (add_monoid.End α) α

The tautological action by add_monoid.End α on α.

This generalizes function.End.apply_mul_action.

Equations

add_monoid.End.apply_distrib_mul_action = {to_mul_action := {to_has_smul := {smul := λ (_x : add_monoid.End α) (_y : α), ⇑_x _y}, one_smul := _, mul_smul := _}, smul_zero := _, smul_add := _}

source

@[simp]

theorem add_monoid.End.smul_def {α : Type u_6} [add_monoid α] (f : add_monoid.End α) (a : α) :

f • a = ⇑f a

source

@[protected, instance]

def add_monoid.End.apply_has_faithful_smul {α : Type u_6} [add_monoid α] :

has_faithful_smul (add_monoid.End α) α

add_monoid.End.apply_distrib_mul_action is faithful.

source

def mul_action.to_End_hom {M : Type u_1} {α : Type u_6} [monoid M] [mul_action M α] :

M →* function.End α

The monoid hom representing a monoid action.

When M is a group, see mul_action.to_perm_hom.

Equations

mul_action.to_End_hom = {to_fun := has_smul.smul mul_action.to_has_smul, map_one' := _, map_mul' := _}

source

@[reducible]

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

mul_action M α

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

See note [reducible non-instances].

Equations

mul_action.of_End_hom f = mul_action.comp_hom α f

source

@[protected, instance]

def add_action.function_End {α : Type u_6} :

add_action (additive (function.End α)) α

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

Equations

add_action.function_End = {to_has_vadd := {vadd := λ (_x : additive (function.End α)) (_y : α), _x _y}, zero_vadd := _, add_vadd := _}

source

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

M →+ additive (function.End α)

The additive monoid hom representing an additive monoid action.

When M is a group, see add_action.to_perm_hom.

Equations

add_action.to_End_hom = {to_fun := has_vadd.vadd add_action.to_has_vadd, map_zero' := _, map_add' := _}

source

@[reducible]

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

add_action M α

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

See note [reducible non-instances].

Equations

add_action.of_End_hom f = add_action.comp_hom α f

source

@[protected, instance]

def additive.has_vadd {α : Type u_6} {β : Type u_7} [has_smul α β] :

has_vadd (additive α) β

Equations

additive.has_vadd = {vadd := λ (a : additive α), has_smul.smul (⇑additive.to_mul a)}

source

@[protected, instance]

def multiplicative.has_smul {α : Type u_6} {β : Type u_7} [has_vadd α β] :

has_smul (multiplicative α) β

Equations

multiplicative.has_smul = {smul := λ (a : multiplicative α), has_vadd.vadd (⇑multiplicative.to_add a)}

source

@[simp]

theorem to_mul_smul {α : Type u_6} {β : Type u_7} [has_smul α β] (a : additive α) (b : β) :

⇑additive.to_mul a • b = a +ᵥ b

source

@[simp]

theorem of_mul_vadd {α : Type u_6} {β : Type u_7} [has_smul α β] (a : α) (b : β) :

⇑additive.of_mul a +ᵥ b = a • b

source

@[simp]

theorem to_add_vadd {α : Type u_6} {β : Type u_7} [has_vadd α β] (a : multiplicative α) (b : β) :

⇑multiplicative.to_add a +ᵥ b = a • b

source

@[simp]

theorem of_add_smul {α : Type u_6} {β : Type u_7} [has_vadd α β] (a : α) (b : β) :

⇑multiplicative.of_add a • b = a +ᵥ b

source

@[protected, instance]

def additive.add_action {α : Type u_6} {β : Type u_7} [monoid α] [mul_action α β] :

add_action (additive α) β

Equations

additive.add_action = {to_has_vadd := additive.has_vadd mul_action.to_has_smul, zero_vadd := _, add_vadd := _}

source

@[protected, instance]

def multiplicative.mul_action {α : Type u_6} {β : Type u_7} [add_monoid α] [add_action α β] :

mul_action (multiplicative α) β

Equations

multiplicative.mul_action = {to_has_smul := multiplicative.has_smul add_action.to_has_vadd, one_smul := _, mul_smul := _}

source

@[protected, instance]

def additive.add_action_is_pretransitive {α : Type u_6} {β : Type u_7} [monoid α] [mul_action α β] [mul_action.is_pretransitive α β] :

add_action.is_pretransitive (additive α) β

source

@[protected, instance]

def multiplicative.add_action_is_pretransitive {α : Type u_6} {β : Type u_7} [add_monoid α] [add_action α β] [add_action.is_pretransitive α β] :

mul_action.is_pretransitive (multiplicative α) β

source

@[protected, instance]

def additive.vadd_comm_class {α : Type u_6} {β : Type u_7} {γ : Type u_8} [has_smul α γ] [has_smul β γ] [smul_comm_class α β γ] :

vadd_comm_class (additive α) (additive β) γ

source

@[protected, instance]

def multiplicative.smul_comm_class {α : Type u_6} {β : Type u_7} {γ : Type u_8} [has_vadd α γ] [has_vadd β γ] [vadd_comm_class α β γ] :

smul_comm_class (multiplicative α) (multiplicative β) γ

mathlib documentation

Definitions of group actions #

Notation #

Implementation details #

Tags #

Faithful actions #

(Pre)transitive action #

Scalar tower and commuting actions #

`additive`, `multiplicative` #

Definitions of group actions #

Notation #

Implementation details #

Tags #

Faithful actions #

(Pre)transitive action #

Scalar tower and commuting actions #

additive, multiplicative #

`additive`, `multiplicative` #