Scalar actions on and by Mᵐᵒᵖ

This file defines the actions on the opposite type SMul R Mᵐᵒᵖ, and actions by the opposite type, SMul Rᵐᵒᵖ M.

Note that MulOpposite.smul is provided in an earlier file as it is needed to provide the AddMonoid.nsmul and AddCommGroup.zsmul fields.

Notation

With open scoped RightActions, this provides:

• r •> m as an alias for r • m
• m <• r as an alias for MulOpposite.op r • m
• v +ᵥ> p as an alias for v +ᵥ p
• p <+ᵥ v as an alias for AddOpposite.op v +ᵥ p

Actions on the opposite type

Actions on the opposite type just act on the underlying type.

instance MulOpposite.instMulAction {M : Type u_1} {α : Type u_3} [Monoid M] [MulAction M α] : MulAction M αᵐᵒᵖ

Equations

• MulOpposite.instMulAction = MulAction.mk ⋯ ⋯

instance AddOpposite.instAddAction {M : Type u_1} {α : Type u_3} [AddMonoid M] [AddAction M α] : AddAction M αᵃᵒᵖ

Equations

• AddOpposite.instAddAction = AddAction.mk ⋯ ⋯

theorem MulOpposite.instIsScalarTower {M : Type u_1} {N : Type u_2} {α : Type u_3} [SMul M N] [SMul M α] [SMul N α] [IsScalarTower M N α] : IsScalarTower M N αᵐᵒᵖ

theorem AddOpposite.instIsScalarTower {M : Type u_1} {N : Type u_2} {α : Type u_3} [VAdd M N] [VAdd M α] [VAdd N α] [VAddAssocClass M N α] : VAddAssocClass M N αᵃᵒᵖ

theorem MulOpposite.instSMulCommClass {M : Type u_1} {N : Type u_2} {α : Type u_3} [SMul M α] [SMul N α] [SMulCommClass M N α] : SMulCommClass M N αᵐᵒᵖ

theorem AddOpposite.instVAddCommClass {M : Type u_1} {N : Type u_2} {α : Type u_3} [VAdd M α] [VAdd N α] [VAddCommClass M N α] : VAddCommClass M N αᵃᵒᵖ

theorem MulOpposite.instIsCentralScalar {M : Type u_1} {α : Type u_3} [SMul M α] [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] : IsCentralScalar M αᵐᵒᵖ

theorem AddOpposite.instIsCentralVAdd {M : Type u_1} {α : Type u_3} [VAdd M α] [VAdd Mᵃᵒᵖ α] [IsCentralVAdd M α] : IsCentralVAdd M αᵃᵒᵖ

theorem MulOpposite.op_smul_eq_op_smul_op {M : Type u_1} {α : Type u_3} [SMul M α] [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] (r : M) (a : α) : MulOpposite.op (r • a) = MulOpposite.op r • MulOpposite.op a

theorem AddOpposite.op_vadd_eq_op_vadd_op {M : Type u_1} {α : Type u_3} [VAdd M α] [VAdd Mᵃᵒᵖ α] [IsCentralVAdd M α] (r : M) (a : α) : AddOpposite.op (r +ᵥ a) = AddOpposite.op r +ᵥ AddOpposite.op a

theorem MulOpposite.unop_smul_eq_unop_smul_unop {M : Type u_1} {α : Type u_3} [SMul M α] [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] (r : Mᵐᵒᵖ) (a : αᵐᵒᵖ) : MulOpposite.unop (r • a) = MulOpposite.unop r • MulOpposite.unop a

theorem AddOpposite.unop_vadd_eq_unop_vadd_unop {M : Type u_1} {α : Type u_3} [VAdd M α] [VAdd Mᵃᵒᵖ α] [IsCentralVAdd M α] (r : Mᵃᵒᵖ) (a : αᵃᵒᵖ) : AddOpposite.unop (r +ᵥ a) = AddOpposite.unop r +ᵥ AddOpposite.unop a

Right actions

In this section we establish SMul αᵐᵒᵖ β as the canonical spelling of right scalar multiplication of β by α, and provide convenient notations.

def RightActions.«term_•>_».delab : Lean.PrettyPrinter.Delaborator.Delab

Pretty printer defined by notation3 command.

Equations

• One or more equations did not get rendered due to their size.

def RightActions.«term_•>_» : Lean.TrailingParserDescr

With open scoped RightActions, an alternative symbol for left actions, r • m.

In lemma names this is still called smul.

Equations

• RightActions.«term_•>_» = Lean.ParserDescr.trailingNode `RightActions.«term_•>_» 74 75 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " •> ") (Lean.ParserDescr.cat `term 74))

def RightActions.«term_<•_».delab : Lean.PrettyPrinter.Delaborator.Delab

Pretty printer defined by notation3 command.

Equations

• One or more equations did not get rendered due to their size.

def RightActions.«term_<•_» : Lean.TrailingParserDescr

With open scoped RightActions, a shorthand for right actions, op r • m.

In lemma names this is still called op_smul.

Equations

• RightActions.«term_<•_» = Lean.ParserDescr.trailingNode `RightActions.«term_<•_» 73 73 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " <• ") (Lean.ParserDescr.cat `term 74))

def RightActions.«term_+ᵥ>_» : Lean.TrailingParserDescr

With open scoped RightActions, an alternative symbol for left actions, r • m.

In lemma names this is still called vadd.

Equations

• RightActions.«term_+ᵥ>_» = Lean.ParserDescr.trailingNode `RightActions.«term_+ᵥ>_» 74 75 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " +ᵥ> ") (Lean.ParserDescr.cat `term 74))

def RightActions.«term_+ᵥ>_».delab : Lean.PrettyPrinter.Delaborator.Delab

Pretty printer defined by notation3 command.

Equations

• One or more equations did not get rendered due to their size.

def RightActions.«term_<+ᵥ_» : Lean.TrailingParserDescr

With open scoped RightActions, a shorthand for right actions, op r +ᵥ m.

In lemma names this is still called op_vadd.

Equations

• RightActions.«term_<+ᵥ_» = Lean.ParserDescr.trailingNode `RightActions.«term_<+ᵥ_» 73 73 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " <+ᵥ ") (Lean.ParserDescr.cat `term 74))

def RightActions.«term_<+ᵥ_».delab : Lean.PrettyPrinter.Delaborator.Delab

Pretty printer defined by notation3 command.

Equations

• One or more equations did not get rendered due to their size.

theorem op_smul_op_smul {α : Type u_3} {β : Type u_4} [Monoid α] [MulAction αᵐᵒᵖ β] (b : β) (a₁ a₂ : α) : MulOpposite.op a₂ • MulOpposite.op a₁ • b = MulOpposite.op (a₁ * a₂) • b

theorem op_vadd_op_vadd {α : Type u_3} {β : Type u_4} [AddMonoid α] [AddAction αᵃᵒᵖ β] (b : β) (a₁ a₂ : α) : AddOpposite.op a₂ +ᵥ AddOpposite.op a₁ +ᵥ b = AddOpposite.op (a₁ + a₂) +ᵥ b

theorem op_smul_mul {α : Type u_3} {β : Type u_4} [Monoid α] [MulAction αᵐᵒᵖ β] (b : β) (a₁ a₂ : α) : MulOpposite.op (a₁ * a₂) • b = MulOpposite.op a₂ • MulOpposite.op a₁ • b

theorem op_vadd_add {α : Type u_3} {β : Type u_4} [AddMonoid α] [AddAction αᵃᵒᵖ β] (b : β) (a₁ a₂ : α) : AddOpposite.op (a₁ + a₂) +ᵥ b = AddOpposite.op a₂ +ᵥ AddOpposite.op a₁ +ᵥ b

Actions by the opposite type (right actions)

In Mul.toSMul in another file, we define the left action a₁ • a₂ = a₁ * a₂. For the multiplicative opposite, we define MulOpposite.op a₁ • a₂ = a₂ * a₁, with the multiplication reversed.

instance Mul.toHasOppositeSMul {α : Type u_3} [Mul α] : SMul αᵐᵒᵖ α

Like Mul.toSMul, but multiplies on the right.

See also Monoid.toOppositeMulAction and MonoidWithZero.toOppositeMulActionWithZero.

Equations

• Mul.toHasOppositeSMul = { smul := fun (c : αᵐᵒᵖ) (x : α) => x * MulOpposite.unop c }

instance Add.toHasOppositeVAdd {α : Type u_3} [Add α] : VAdd αᵃᵒᵖ α

Like Add.toVAdd, but adds on the right.

See also AddMonoid.toOppositeAddAction.

Equations

• Add.toHasOppositeVAdd = { vadd := fun (c : αᵃᵒᵖ) (x : α) => x + AddOpposite.unop c }

theorem op_smul_eq_mul {α : Type u_3} [Mul α] {a a' : α} : MulOpposite.op a • a' = a' * a

theorem op_vadd_eq_add {α : Type u_3} [Add α] {a a' : α} : AddOpposite.op a +ᵥ a' = a' + a

@[simp]

theorem MulOpposite.smul_eq_mul_unop {α : Type u_3} [Mul α] {a : αᵐᵒᵖ} {a' : α} : a • a' = a' * MulOpposite.unop a

@[simp]

theorem AddOpposite.vadd_eq_add_unop {α : Type u_3} [Add α] {a : αᵃᵒᵖ} {a' : α} : a +ᵥ a' = a' + AddOpposite.unop a

theorem MulAction.OppositeRegular.isPretransitive {G : Type u_5} [Group G] : MulAction.IsPretransitive Gᵐᵒᵖ G

The right regular action of a group on itself is transitive.

theorem AddAction.OppositeRegular.isPretransitive {G : Type u_5} [AddGroup G] : AddAction.IsPretransitive Gᵃᵒᵖ G

The right regular action of an additive group on itself is transitive.

theorem Semigroup.opposite_smulCommClass {α : Type u_3} [Semigroup α] : SMulCommClass αᵐᵒᵖ α α

theorem AddSemigroup.opposite_vaddCommClass {α : Type u_3} [AddSemigroup α] : VAddCommClass αᵃᵒᵖ α α

theorem Semigroup.opposite_smulCommClass' {α : Type u_3} [Semigroup α] : SMulCommClass α αᵐᵒᵖ α

theorem AddSemigroup.opposite_vaddCommClass' {α : Type u_3} [AddSemigroup α] : VAddCommClass α αᵃᵒᵖ α

theorem CommSemigroup.isCentralScalar {α : Type u_3} [CommSemigroup α] : IsCentralScalar α α

theorem AddCommSemigroup.isCentralVAdd {α : Type u_3} [AddCommSemigroup α] : IsCentralVAdd α α

instance Monoid.toOppositeMulAction {α : Type u_3} [Monoid α] : MulAction αᵐᵒᵖ α

Like Monoid.toMulAction, but multiplies on the right.

Equations

• Monoid.toOppositeMulAction = MulAction.mk ⋯ ⋯

instance AddMonoid.toOppositeAddAction {α : Type u_3} [AddMonoid α] : AddAction αᵃᵒᵖ α

Like AddMonoid.toAddAction, but adds on the right.

Equations

• AddMonoid.toOppositeAddAction = AddAction.mk ⋯ ⋯

theorem IsScalarTower.opposite_mid {M : Type u_5} {N : Type u_6} [Mul N] [SMul M N] [SMulCommClass M N N] : IsScalarTower M Nᵐᵒᵖ N

theorem VAddAssocClass.opposite_mid {M : Type u_5} {N : Type u_6} [Add N] [VAdd M N] [VAddCommClass M N N] : VAddAssocClass M Nᵃᵒᵖ N

theorem SMulCommClass.opposite_mid {M : Type u_5} {N : Type u_6} [Mul N] [SMul M N] [IsScalarTower M N N] : SMulCommClass M Nᵐᵒᵖ N

theorem VAddCommClass.opposite_mid {M : Type u_5} {N : Type u_6} [Add N] [VAdd M N] [VAddAssocClass M N N] : VAddCommClass M Nᵃᵒᵖ N

theorem LeftCancelMonoid.toFaithfulSMul_opposite {α : Type u_3} [LeftCancelMonoid α] : FaithfulSMul αᵐᵒᵖ α

Monoid.toOppositeMulAction is faithful on cancellative monoids.

theorem AddLeftCancelMonoid.toFaithfulVAdd_opposite {α : Type u_3} [AddLeftCancelMonoid α] : FaithfulVAdd αᵃᵒᵖ α

AddMonoid.toOppositeAddAction is faithful on cancellative monoids.