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.

theorem AddOpposite.instAddAction.proof_1 {M : Type u_2} {α : Type u_1} [AddMonoid M] [AddAction M α] : ∀ (x : αᵃᵒᵖ), 0 +ᵥ x = x

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

Equations

• AddOpposite.instAddAction = AddAction.mk ⋯ ⋯

theorem AddOpposite.instAddAction.proof_2 {M : Type u_2} {α : Type u_1} [AddMonoid M] [AddAction M α] : ∀ (x x_1 : M) (x_2 : αᵃᵒᵖ), x + x_1 +ᵥ x_2 = x +ᵥ (x_1 +ᵥ x_2)

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

Equations

• MulOpposite.instMulAction = MulAction.mk ⋯ ⋯

instance MulOpposite.instDistribMulAction {M : Type u_2} {α : Type u_4} [Monoid M] [AddMonoid α] [DistribMulAction M α] : DistribMulAction M αᵐᵒᵖ

Equations

• MulOpposite.instDistribMulAction = DistribMulAction.mk ⋯ ⋯

instance MulOpposite.instMulDistribMulAction {M : Type u_2} {α : Type u_4} [Monoid M] [Monoid α] [MulDistribMulAction M α] : MulDistribMulAction M αᵐᵒᵖ

Equations

• MulOpposite.instMulDistribMulAction = MulDistribMulAction.mk ⋯ ⋯

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

Equations

• ⋯ = ⋯

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

Equations

• ⋯ = ⋯

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

Equations

• ⋯ = ⋯

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

Equations

• ⋯ = ⋯

instance AddOpposite.instIsCentralVAdd {M : Type u_2} {α : Type u_4} [VAdd M α] [VAdd Mᵃᵒᵖ α] [IsCentralVAdd M α] : IsCentralVAdd M αᵃᵒᵖ

Equations

• ⋯ = ⋯

instance MulOpposite.instIsCentralScalar {M : Type u_2} {α : Type u_4} [SMul M α] [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] : IsCentralScalar M αᵐᵒᵖ

Equations

• ⋯ = ⋯

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

theorem MulOpposite.unop_smul_eq_unop_smul_unop {M : Type u_2} {α : Type u_4} [SMul M α] [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] (r : Mᵐᵒᵖ) (a : αᵐᵒᵖ) : MulOpposite.unop (r • a) = MulOpposite.unop r • MulOpposite.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_•>_» : 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_<•_».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_vadd_op_vadd {α : Type u_5} {β : Type u_6} [AddMonoid α] [AddAction αᵃᵒᵖ β] (b : β) (a₁ : α) (a₂ : α) : AddOpposite.op a₂ +ᵥ (AddOpposite.op a₁ +ᵥ b) = AddOpposite.op (a₁ + a₂) +ᵥ b

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

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

theorem op_smul_mul {α : Type u_5} {β : Type u_6} [Monoid α] [MulAction αᵐᵒᵖ β] (b : β) (a₁ : α) (a₂ : α) : MulOpposite.op (a₁ * a₂) • b = MulOpposite.op a₂ • MulOpposite.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 Add.toHasOppositeVAdd {α : Type u_4} [Add α] : VAdd αᵃᵒᵖ α

Like Add.toVAdd, but adds on the right.

See also AddMonoid.to_OppositeAddAction.

Equations

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

instance Mul.toHasOppositeSMul {α : Type u_4} [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 }

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

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

@[simp]

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

@[simp]

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

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

Equations

• ⋯ = ⋯

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

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

Equations

• ⋯ = ⋯

instance AddSemigroup.opposite_vaddCommClass {α : Type u_4} [AddSemigroup α] : VAddCommClass αᵃᵒᵖ α α

Equations

• ⋯ = ⋯

instance Semigroup.opposite_smulCommClass {α : Type u_4} [Semigroup α] : SMulCommClass αᵐᵒᵖ α α

Equations

• ⋯ = ⋯

instance AddSemigroup.opposite_vaddCommClass' {α : Type u_4} [AddSemigroup α] : VAddCommClass α αᵃᵒᵖ α

Equations

• ⋯ = ⋯

instance Semigroup.opposite_smulCommClass' {α : Type u_4} [Semigroup α] : SMulCommClass α αᵐᵒᵖ α

Equations

• ⋯ = ⋯

instance AddCommSemigroup.isCentralVAdd {α : Type u_4} [AddCommSemigroup α] : IsCentralVAdd α α

Equations

• ⋯ = ⋯

instance CommSemigroup.isCentralScalar {α : Type u_4} [CommSemigroup α] : IsCentralScalar α α

Equations

• ⋯ = ⋯

theorem AddMonoid.toOppositeAddAction.proof_2 {α : Type u_1} [AddMonoid α] : ∀ (x x_1 : αᵃᵒᵖ) (x_2 : α), x_2 + (AddOpposite.unop x_1 + AddOpposite.unop x) = x_2 + AddOpposite.unop x_1 + AddOpposite.unop x

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

Like AddMonoid.toAddAction, but adds on the right.

Equations

• AddMonoid.toOppositeAddAction = AddAction.mk ⋯ ⋯

theorem AddMonoid.toOppositeAddAction.proof_1 {α : Type u_1} [AddMonoid α] (a : α) : a + 0 = a

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

Like Monoid.toMulAction, but multiplies on the right.

Equations

• Monoid.toOppositeMulAction = MulAction.mk ⋯ ⋯

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

Equations

• ⋯ = ⋯

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

Equations

• ⋯ = ⋯

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

Equations

• ⋯ = ⋯

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

Equations

• ⋯ = ⋯

instance AddLeftCancelMonoid.toFaithfulVAdd_opposite {α : Type u_4} [AddLeftCancelMonoid α] : FaithfulVAdd αᵃᵒᵖ α

AddMonoid.toOppositeAddAction is faithful on cancellative monoids.

Equations

• ⋯ = ⋯

instance LeftCancelMonoid.toFaithfulSMul_opposite {α : Type u_4} [LeftCancelMonoid α] : FaithfulSMul αᵐᵒᵖ α

Monoid.toOppositeMulAction is faithful on cancellative monoids.

Equations

• ⋯ = ⋯

instance CancelMonoidWithZero.toFaithfulSMul_opposite {α : Type u_4} [CancelMonoidWithZero α] [Nontrivial α] : FaithfulSMul αᵐᵒᵖ α

Monoid.toOppositeMulAction is faithful on nontrivial cancellative monoids with zero.

Equations

• ⋯ = ⋯