File: Mathlib/Algebra/Group/Action/Prod.lean

full_name: Prod.smul
code: @[to_additive] instance smul : SMul M (α × β) 
goal: SMul M (α × β)

full_name: Prod.vadd
code: @[to_additive] instance smul : SMul M (α × β) 
goal: VAdd M (α × β)

full_name: Prod.smul_fst
code: @[to_additive (attr := simp)] lemma smul_fst : (a • x).1 = a • x.1 
goal: (a • x).1 = a • x.1

full_name: Prod.vadd_fst
code: @[to_additive (attr := simp)] lemma smul_fst : (a • x).1 = a • x.1 
goal: (a +ᵥ x).1 = a +ᵥ x.1

full_name: Prod.smul_snd
code: @[to_additive (attr := simp)] lemma smul_snd : (a • x).2 = a • x.2 
goal: (a • x).2 = a • x.2

full_name: Prod.vadd_snd
code: @[to_additive (attr := simp)] lemma smul_snd : (a • x).2 = a • x.2 
goal: (a +ᵥ x).2 = a +ᵥ x.2

full_name: Prod.smul_mk
code: @[to_additive (attr := simp)]
lemma smul_mk (a : M) (b : α) (c : β) : a • (b, c) = (a • b, a • c) 
goal: a • (b, c) = (a • b, a • c)

full_name: Prod.vadd_mk
code: @[to_additive (attr := simp)]
lemma smul_mk (a : M) (b : α) (c : β) : a • (b, c) = (a • b, a • c) 
goal: a +ᵥ (b, c) = (a +ᵥ b, a +ᵥ c)

full_name: Prod.vadd_def
code: @[to_additive]
lemma smul_def (a : M) (x : α × β) : a • x = (a • x.1, a • x.2) 
goal: a +ᵥ x = (a +ᵥ x.1, a +ᵥ x.2)

full_name: Prod.smul_def
code: @[to_additive]
lemma smul_def (a : M) (x : α × β) : a • x = (a • x.1, a • x.2) 
goal: a • x = (a • x.1, a • x.2)

full_name: Prod.vadd_swap
code: @[to_additive (attr := simp)] lemma smul_swap : (a • x).swap = a • x.swap 
goal: (a +ᵥ x).swap = a +ᵥ x.swap

full_name: Prod.smul_swap
code: @[to_additive (attr := simp)] lemma smul_swap : (a • x).swap = a • x.swap 
goal: (a • x).swap = a • x.swap

full_name: Prod.pow
code: @[to_additive existing smul]
instance pow : Pow (α × β) E 
goal: Pow (α × β) E

full_name: Prod.pow_fst
code: @[to_additive existing (attr := simp) (reorder := 6 7) smul_fst]
lemma pow_fst (p : α × β) (c : E) : (p ^ c).fst = p.fst ^ c 
goal: (p ^ c).1 = p.1 ^ c

full_name: Prod.pow_snd
code: @[to_additive existing (attr := simp) (reorder := 6 7) smul_snd]
lemma pow_snd (p : α × β) (c : E) : (p ^ c).snd = p.snd ^ c 
goal: (p ^ c).2 = p.2 ^ c

full_name: Prod.pow_mk
code: @[to_additive existing (attr := simp) (reorder := 6 7) smul_mk]
lemma pow_mk (c : E) (a : α) (b : β) : Prod.mk a b ^ c = Prod.mk (a ^ c) (b ^ c) 
goal: (a, b) ^ c = (a ^ c, b ^ c)

full_name: Prod.pow_def
code: @[to_additive existing (reorder := 6 7) smul_def]
lemma pow_def (p : α × β) (c : E) : p ^ c = (p.1 ^ c, p.2 ^ c) 
goal: p ^ c = (p.1 ^ c, p.2 ^ c)

full_name: Prod.pow_swap
code: @[to_additive existing (attr := simp) (reorder := 6 7) smul_swap]
lemma pow_swap (p : α × β) (c : E) : (p ^ c).swap = p.swap ^ c 
goal: (p ^ c).swap = p.swap ^ c

full_name: Prod.isScalarTower
code: @[to_additive vaddAssocClass]
instance isScalarTower [SMul M N] [IsScalarTower M N α] [IsScalarTower M N β] :
    IsScalarTower M N (α × β) 
goal: IsScalarTower M N (α × β)

full_name: Prod.vaddAssocClass
code: @[to_additive vaddAssocClass]
instance isScalarTower [SMul M N] [IsScalarTower M N α] [IsScalarTower M N β] :
    IsScalarTower M N (α × β) 
goal: VAddAssocClass M N (α × β)

full_name: Prod.smulCommClass
code: @[to_additive]
instance smulCommClass [SMulCommClass M N α] [SMulCommClass M N β] : SMulCommClass M N (α × β) 
goal: SMulCommClass M N (α × β)

full_name: Prod.vaddCommClass
code: @[to_additive]
instance smulCommClass [SMulCommClass M N α] [SMulCommClass M N β] : SMulCommClass M N (α × β) 
goal: VAddCommClass M N (α × β)

full_name: Prod.isCentralScalar
code: @[to_additive]
instance isCentralScalar [SMul Mᵐᵒᵖ α] [SMul Mᵐᵒᵖ β] [IsCentralScalar M α] [IsCentralScalar M β] :
    IsCentralScalar M (α × β) 
goal: IsCentralScalar M (α × β)

full_name: Prod.isCentralVAdd
code: @[to_additive]
instance isCentralScalar [SMul Mᵐᵒᵖ α] [SMul Mᵐᵒᵖ β] [IsCentralScalar M α] [IsCentralScalar M β] :
    IsCentralScalar M (α × β) 
goal: IsCentralVAdd M (α × β)

full_name: Prod.faithfulSMulLeft
code: @[to_additive]
instance faithfulSMulLeft [FaithfulSMul M α] [Nonempty β] : FaithfulSMul M (α × β) 
goal: FaithfulSMul M (α × β)

full_name: Prod.faithfulVAddLeft
code: @[to_additive]
instance faithfulSMulLeft [FaithfulSMul M α] [Nonempty β] : FaithfulSMul M (α × β) 
goal: FaithfulVAdd M (α × β)

full_name: Prod.faithfulSMulRight
code: @[to_additive]
instance faithfulSMulRight [Nonempty α] [FaithfulSMul M β] : FaithfulSMul M (α × β) 
goal: FaithfulSMul M (α × β)

full_name: Prod.faithfulVAddRight
code: @[to_additive]
instance faithfulSMulRight [Nonempty α] [FaithfulSMul M β] : FaithfulSMul M (α × β) 
goal: FaithfulVAdd M (α × β)

full_name: Prod.smulCommClassBoth
code: @[to_additive]
instance smulCommClassBoth [Mul N] [Mul P] [SMul M N] [SMul M P] [SMulCommClass M N N]
    [SMulCommClass M P P] : SMulCommClass M (N × P) (N × P) 
goal: SMulCommClass M (N × P) (N × P)

full_name: Prod.vaddCommClassBoth
code: @[to_additive]
instance smulCommClassBoth [Mul N] [Mul P] [SMul M N] [SMul M P] [SMulCommClass M N N]
    [SMulCommClass M P P] : SMulCommClass M (N × P) (N × P) 
goal: VAddCommClass M (N × P) (N × P)

full_name: Prod.isScalarTowerBoth
code: instance isScalarTowerBoth [Mul N] [Mul P] [SMul M N] [SMul M P] [IsScalarTower M N N]
    [IsScalarTower M P P] : IsScalarTower M (N × P) (N × P) 
goal: IsScalarTower M (N × P) (N × P)

full_name: Prod.mulAction
code: @[to_additive]
instance mulAction [Monoid M] [MulAction M α] [MulAction M β] : MulAction M (α × β) 
goal: MulAction M (α × β)

full_name: Prod.addAction
code: @[to_additive]
instance mulAction [Monoid M] [MulAction M α] [MulAction M β] : MulAction M (α × β) 
goal: AddAction M (α × β)

full_name: smulMulHom
code: /-- Scalar multiplication as a multiplicative homomorphism. -/
@[simps]
def smulMulHom [Monoid α] [Mul β] [MulAction α β] [IsScalarTower α β β] [SMulCommClass α β β] :
    α × β →ₙ* β 
goal: α × β →ₙ* β

full_name: smulMulHom_apply
code: /-- Scalar multiplication as a multiplicative homomorphism. -/
@[simps]
def smulMulHom [Monoid α] [Mul β] [MulAction α β] [IsScalarTower α β β] [SMulCommClass α β β] :
    α × β →ₙ* β 
goal: smulMulHom a = a.1 • a.2

full_name: smulMonoidHom_apply
code: /-- Scalar multiplication as a monoid homomorphism. -/
@[simps]
def smulMonoidHom [Monoid α] [MulOneClass β] [MulAction α β] [IsScalarTower α β β]
    [SMulCommClass α β β] : α × β →* β 
goal: ∀ (a : α × β), smulMonoidHom a = smulMulHom.toFun a

full_name: smulMonoidHom
code: /-- Scalar multiplication as a monoid homomorphism. -/
@[simps]
def smulMonoidHom [Monoid α] [MulOneClass β] [MulAction α β] [IsScalarTower α β β]
    [SMulCommClass α β β] : α × β →* β 
goal: α × β →* β

full_name: AddAction.prodOfVAddCommClass
code: /-- Construct a `MulAction` by a product monoid from `MulAction`s by the factors.
  This is not an instance to avoid diamonds for example when `α := M × N`. -/
@[to_additive AddAction.prodOfVAddCommClass
"Construct an `AddAction` by a product monoid from `AddAction`s by the factors.
This is not an instance to avoid diamonds for example when `α := M × N`."]
abbrev MulAction.prodOfSMulCommClass [MulAction M α] [MulAction N α] [SMulCommClass M N α] :
    MulAction (M × N) α 
goal: AddAction (M × N) α

full_name: MulAction.prodOfSMulCommClass
code: /-- Construct a `MulAction` by a product monoid from `MulAction`s by the factors.
  This is not an instance to avoid diamonds for example when `α := M × N`. -/
@[to_additive AddAction.prodOfVAddCommClass
"Construct an `AddAction` by a product monoid from `AddAction`s by the factors.
This is not an instance to avoid diamonds for example when `α := M × N`."]
abbrev MulAction.prodOfSMulCommClass [MulAction M α] [MulAction N α] [SMulCommClass M N α] :
    MulAction (M × N) α 
goal: MulAction (M × N) α

full_name: MulAction.prodEquiv
code: /-- A `MulAction` by a product monoid is equivalent to commuting `MulAction`s by the factors. -/
@[to_additive AddAction.prodEquiv
"An `AddAction` by a product monoid is equivalent to commuting `AddAction`s by the factors."]
def MulAction.prodEquiv :
    MulAction (M × N) α ≃ Σ' (_ : MulAction M α) (_ : MulAction N α), SMulCommClass M N α 
goal: MulAction (M × N) α ≃ (x : MulAction M α) ×' (x_1 : MulAction N α) ×' SMulCommClass M N α

full_name: AddAction.prodEquiv
code: /-- A `MulAction` by a product monoid is equivalent to commuting `MulAction`s by the factors. -/
@[to_additive AddAction.prodEquiv
"An `AddAction` by a product monoid is equivalent to commuting `AddAction`s by the factors."]
def MulAction.prodEquiv :
    MulAction (M × N) α ≃ Σ' (_ : MulAction M α) (_ : MulAction N α), SMulCommClass M N α 
goal: AddAction (M × N) α ≃ (x : AddAction M α) ×' (x_1 : AddAction N α) ×' VAddCommClass M N α