File: Mathlib/Algebra/Group/TypeTags.lean

full_name: Additive
code: /-- If `α` carries some multiplicative structure, then `Additive α` carries the corresponding
additive structure. -/
def Additive (α : Type*) 
goal: Type u_1

full_name: Multiplicative
code: /-- If `α` carries some additive structure, then `Multiplicative α` carries the corresponding
multiplicative structure. -/
def Multiplicative (α : Type*) 
goal: Type u_1

full_name: Additive.ofMul
code: /-- Reinterpret `x : α` as an element of `Additive α`. -/
def ofMul : α ≃ Additive α 
goal: α ≃ Additive α

full_name: Additive.toMul
code: /-- Reinterpret `x : Additive α` as an element of `α`. -/
def toMul : Additive α ≃ α 
goal: Additive α ≃ α

full_name: Additive.ofMul_symm_eq
code: @[simp]
theorem ofMul_symm_eq : (@ofMul α).symm = toMul 
goal: Additive.ofMul.symm = Additive.toMul

full_name: Additive.toMul_symm_eq
code: @[simp]
theorem toMul_symm_eq : (@toMul α).symm = ofMul 
goal: Additive.toMul.symm = Additive.ofMul

full_name: Additive.forall
code: @[simp]
protected lemma «forall» {p : Additive α → Prop} : (∀ a, p a) ↔ ∀ a, p (ofMul a) 
goal: (∀ (a : Additive α), p a) ↔ ∀ (a : α), p (Additive.ofMul a)

full_name: Additive.exists
code: @[simp]
protected lemma «exists» {p : Additive α → Prop} : (∃ a, p a) ↔ ∃ a, p (ofMul a) 
goal: (∃ a, p a) ↔ ∃ a, p (Additive.ofMul a)

full_name: Additive.rec
code: /-- Recursion principle for `Additive`, supported by `cases` and `induction`. -/
@[elab_as_elim, cases_eliminator, induction_eliminator]
def rec {motive : Additive α → Sort*} (ofMul : ∀ a, motive (ofMul a)) : ∀ a, motive a 
goal: motive a

full_name: Multiplicative.ofAdd
code: /-- Reinterpret `x : α` as an element of `Multiplicative α`. -/
def ofAdd : α ≃ Multiplicative α 
goal: α ≃ Multiplicative α

full_name: Multiplicative.toAdd
code: /-- Reinterpret `x : Multiplicative α` as an element of `α`. -/
def toAdd : Multiplicative α ≃ α 
goal: Multiplicative α ≃ α

full_name: Multiplicative.ofAdd_symm_eq
code: @[simp]
theorem ofAdd_symm_eq : (@ofAdd α).symm = toAdd 
goal: Multiplicative.ofAdd.symm = Multiplicative.toAdd

full_name: Multiplicative.toAdd_symm_eq
code: @[simp]
theorem toAdd_symm_eq : (@toAdd α).symm = ofAdd 
goal: Multiplicative.toAdd.symm = Multiplicative.ofAdd

full_name: Multiplicative.forall
code: @[simp]
protected lemma «forall» {p : Multiplicative α → Prop} : (∀ a, p a) ↔ ∀ a, p (ofAdd a) 
goal: (∀ (a : Multiplicative α), p a) ↔ ∀ (a : α), p (Multiplicative.ofAdd a)

full_name: Multiplicative.exists
code: @[simp]
protected lemma «exists» {p : Multiplicative α → Prop} : (∃ a, p a) ↔ ∃ a, p (ofAdd a) 
goal: (∃ a, p a) ↔ ∃ a, p (Multiplicative.ofAdd a)

full_name: Multiplicative.rec
code: /-- Recursion principle for `Multiplicative`, supported by `cases` and `induction`. -/
@[elab_as_elim, cases_eliminator, induction_eliminator]
def rec {motive : Multiplicative α → Sort*} (ofAdd : ∀ a, motive (ofAdd a)) : ∀ a, motive a 
goal: motive a

full_name: toAdd_ofAdd
code: @[simp]
theorem toAdd_ofAdd (x : α) : toAdd (ofAdd x) = x 
goal: Multiplicative.toAdd (Multiplicative.ofAdd x) = x

full_name: ofAdd_toAdd
code: @[simp]
theorem ofAdd_toAdd (x : Multiplicative α) : ofAdd (toAdd x) = x 
goal: Multiplicative.ofAdd (Multiplicative.toAdd x) = x

full_name: toMul_ofMul
code: @[simp]
theorem toMul_ofMul (x : α) : toMul (ofMul x) = x 
goal: Additive.toMul (Additive.ofMul x) = x

full_name: ofMul_toMul
code: @[simp]
theorem ofMul_toMul (x : Additive α) : ofMul (toMul x) = x 
goal: Additive.ofMul (Additive.toMul x) = x

full_name: instSubsingletonAdditive
code: instance [Subsingleton α] : Subsingleton (Additive α) 
goal: Subsingleton (Additive α)

full_name: instSubsingletonMultiplicative
code: instance [Subsingleton α] : Subsingleton (Multiplicative α) 
goal: Subsingleton (Multiplicative α)

full_name: instInhabitedAdditive
code: instance [Inhabited α] : Inhabited (Additive α) 
goal: Inhabited (Additive α)

full_name: instInhabitedMultiplicative
code: instance [Inhabited α] : Inhabited (Multiplicative α) 
goal: Inhabited (Multiplicative α)

full_name: instUniqueAdditive
code: instance [Unique α] : Unique (Additive α) 
goal: Unique (Additive α)

full_name: instUniqueMultiplicative
code: instance [Unique α] : Unique (Multiplicative α) 
goal: Unique (Multiplicative α)

full_name: instFiniteAdditive
code: instance [Finite α] : Finite (Additive α) 
goal: Finite (Additive α)

full_name: instFiniteMultiplicative
code: instance [Finite α] : Finite (Multiplicative α) 
goal: Finite (Multiplicative α)

full_name: instInfiniteAdditive
code: instance [h : Infinite α] : Infinite (Additive α) 
goal: Infinite (Additive α)

full_name: instInfiniteMultiplicative
code: instance [h : Infinite α] : Infinite (Multiplicative α) 
goal: Infinite (Multiplicative α)

full_name: instDecidableEqMultiplicative
code: instance [h : DecidableEq α] : DecidableEq (Multiplicative α) 
goal: DecidableEq (Multiplicative α)

full_name: instDecidableEqAdditive
code: instance [h : DecidableEq α] : DecidableEq (Additive α) 
goal: DecidableEq (Additive α)

full_name: Additive.instNontrivial
code: instance Additive.instNontrivial [Nontrivial α] : Nontrivial (Additive α) 
goal: Nontrivial (Additive α)

full_name: Multiplicative.instNontrivial
code: instance Multiplicative.instNontrivial [Nontrivial α] : Nontrivial (Multiplicative α) 
goal: Nontrivial (Multiplicative α)

full_name: Additive.add
code: instance Additive.add [Mul α] : Add (Additive α) 
goal: Add (Additive α)

full_name: Multiplicative.mul
code: instance Multiplicative.mul [Add α] : Mul (Multiplicative α) 
goal: Mul (Multiplicative α)

full_name: ofAdd_add
code: @[simp]
theorem ofAdd_add [Add α] (x y : α) : ofAdd (x + y) = ofAdd x * ofAdd y 
goal: Multiplicative.ofAdd (x + y) = Multiplicative.ofAdd x * Multiplicative.ofAdd y

full_name: toAdd_mul
code: @[simp]
theorem toAdd_mul [Add α] (x y : Multiplicative α) : toAdd (x * y) = toAdd x + toAdd y 
goal: Multiplicative.toAdd (x * y) = Multiplicative.toAdd x + Multiplicative.toAdd y

full_name: ofMul_mul
code: @[simp]
theorem ofMul_mul [Mul α] (x y : α) : ofMul (x * y) = ofMul x + ofMul y 
goal: Additive.ofMul (x * y) = Additive.ofMul x + Additive.ofMul y

full_name: toMul_add
code: @[simp]
theorem toMul_add [Mul α] (x y : Additive α) : toMul (x + y) = toMul x * toMul y 
goal: Additive.toMul (x + y) = Additive.toMul x * Additive.toMul y

full_name: Additive.addSemigroup
code: instance Additive.addSemigroup [Semigroup α] : AddSemigroup (Additive α) 
goal: AddSemigroup (Additive α)

full_name: Multiplicative.semigroup
code: instance Multiplicative.semigroup [AddSemigroup α] : Semigroup (Multiplicative α) 
goal: Semigroup (Multiplicative α)

full_name: Additive.addCommSemigroup
code: instance Additive.addCommSemigroup [CommSemigroup α] : AddCommSemigroup (Additive α) 
goal: AddCommSemigroup (Additive α)

full_name: Multiplicative.commSemigroup
code: instance Multiplicative.commSemigroup [AddCommSemigroup α] : CommSemigroup (Multiplicative α) 
goal: CommSemigroup (Multiplicative α)

full_name: Additive.isLeftCancelAdd
code: instance Additive.isLeftCancelAdd [Mul α] [IsLeftCancelMul α] : IsLeftCancelAdd (Additive α) 
goal: IsLeftCancelAdd (Additive α)

full_name: Multiplicative.isLeftCancelMul
code: instance Multiplicative.isLeftCancelMul [Add α] [IsLeftCancelAdd α] :
    IsLeftCancelMul (Multiplicative α) 
goal: IsLeftCancelMul (Multiplicative α)

full_name: Additive.isRightCancelAdd
code: instance Additive.isRightCancelAdd [Mul α] [IsRightCancelMul α] : IsRightCancelAdd (Additive α) 
goal: IsRightCancelAdd (Additive α)

full_name: Multiplicative.isRightCancelMul
code: instance Multiplicative.isRightCancelMul [Add α] [IsRightCancelAdd α] :
    IsRightCancelMul (Multiplicative α) 
goal: IsRightCancelMul (Multiplicative α)

full_name: Additive.isCancelAdd
code: instance Additive.isCancelAdd [Mul α] [IsCancelMul α] : IsCancelAdd (Additive α) 
goal: IsCancelAdd (Additive α)

full_name: Multiplicative.isCancelMul
code: instance Multiplicative.isCancelMul [Add α] [IsCancelAdd α] : IsCancelMul (Multiplicative α) 
goal: IsCancelMul (Multiplicative α)

full_name: Additive.addLeftCancelSemigroup
code: instance Additive.addLeftCancelSemigroup [LeftCancelSemigroup α] :
    AddLeftCancelSemigroup (Additive α) 
goal: AddLeftCancelSemigroup (Additive α)

full_name: Multiplicative.leftCancelSemigroup
code: instance Multiplicative.leftCancelSemigroup [AddLeftCancelSemigroup α] :
    LeftCancelSemigroup (Multiplicative α) 
goal: LeftCancelSemigroup (Multiplicative α)

full_name: Additive.addRightCancelSemigroup
code: instance Additive.addRightCancelSemigroup [RightCancelSemigroup α] :
    AddRightCancelSemigroup (Additive α) 
goal: AddRightCancelSemigroup (Additive α)

full_name: Multiplicative.rightCancelSemigroup
code: instance Multiplicative.rightCancelSemigroup [AddRightCancelSemigroup α] :
    RightCancelSemigroup (Multiplicative α) 
goal: RightCancelSemigroup (Multiplicative α)

full_name: instZeroAdditiveOfOne
code: instance [One α] : Zero (Additive α) 
goal: Zero (Additive α)

full_name: ofMul_one
code: @[simp]
theorem ofMul_one [One α] : @Additive.ofMul α 1 = 0 
goal: Additive.ofMul 1 = 0

full_name: ofMul_eq_zero
code: @[simp]
theorem ofMul_eq_zero {A : Type*} [One A] {x : A} : Additive.ofMul x = 0 ↔ x = 1 
goal: Additive.ofMul x = 0 ↔ x = 1

full_name: toMul_zero
code: @[simp]
theorem toMul_zero [One α] : toMul (0 : Additive α) = 1 
goal: Additive.toMul 0 = 1

full_name: toMul_eq_one
code: @[simp]
lemma toMul_eq_one {α : Type*} [One α] {x : Additive α} :
    Additive.toMul x = 1 ↔ x = 0 
goal: Additive.toMul x = 1 ↔ x = 0

full_name: instOneMultiplicativeOfZero
code: instance [Zero α] : One (Multiplicative α) 
goal: One (Multiplicative α)

full_name: ofAdd_zero
code: @[simp]
theorem ofAdd_zero [Zero α] : @Multiplicative.ofAdd α 0 = 1 
goal: Multiplicative.ofAdd 0 = 1

full_name: ofAdd_eq_one
code: @[simp]
theorem ofAdd_eq_one {A : Type*} [Zero A] {x : A} : Multiplicative.ofAdd x = 1 ↔ x = 0 
goal: Multiplicative.ofAdd x = 1 ↔ x = 0

full_name: toAdd_one
code: @[simp]
theorem toAdd_one [Zero α] : toAdd (1 : Multiplicative α) = 0 
goal: Multiplicative.toAdd 1 = 0

full_name: toAdd_eq_zero
code: @[simp]
lemma toAdd_eq_zero {α : Type*} [Zero α] {x : Multiplicative α} :
    Multiplicative.toAdd x = 0 ↔ x = 1 
goal: Multiplicative.toAdd x = 0 ↔ x = 1

full_name: Additive.addZeroClass
code: instance Additive.addZeroClass [MulOneClass α] : AddZeroClass (Additive α) 
goal: AddZeroClass (Additive α)

full_name: Multiplicative.mulOneClass
code: instance Multiplicative.mulOneClass [AddZeroClass α] : MulOneClass (Multiplicative α) 
goal: MulOneClass (Multiplicative α)

full_name: Additive.addMonoid
code: instance Additive.addMonoid [h : Monoid α] : AddMonoid (Additive α) 
goal: AddMonoid (Additive α)

full_name: Multiplicative.monoid
code: instance Multiplicative.monoid [h : AddMonoid α] : Monoid (Multiplicative α) 
goal: Monoid (Multiplicative α)

full_name: ofMul_pow
code: @[simp]
theorem ofMul_pow [Monoid α] (n : ℕ) (a : α) : ofMul (a ^ n) = n • ofMul a 
goal: Additive.ofMul (a ^ n) = n • Additive.ofMul a

full_name: toMul_nsmul
code: @[simp]
theorem toMul_nsmul [Monoid α] (n : ℕ) (a : Additive α) : toMul (n • a) = toMul a ^ n 
goal: Additive.toMul (n • a) = Additive.toMul a ^ n

full_name: ofAdd_nsmul
code: @[simp]
theorem ofAdd_nsmul [AddMonoid α] (n : ℕ) (a : α) : ofAdd (n • a) = ofAdd a ^ n 
goal: Multiplicative.ofAdd (n • a) = Multiplicative.ofAdd a ^ n

full_name: toAdd_pow
code: @[simp]
theorem toAdd_pow [AddMonoid α] (a : Multiplicative α) (n : ℕ) : toAdd (a ^ n) = n • toAdd a 
goal: Multiplicative.toAdd (a ^ n) = n • Multiplicative.toAdd a

full_name: Additive.addLeftCancelMonoid
code: instance Additive.addLeftCancelMonoid [LeftCancelMonoid α] : AddLeftCancelMonoid (Additive α) 
goal: AddLeftCancelMonoid (Additive α)

full_name: Multiplicative.leftCancelMonoid
code: instance Multiplicative.leftCancelMonoid [AddLeftCancelMonoid α] :
    LeftCancelMonoid (Multiplicative α) 
goal: LeftCancelMonoid (Multiplicative α)

full_name: Additive.addRightCancelMonoid
code: instance Additive.addRightCancelMonoid [RightCancelMonoid α] : AddRightCancelMonoid (Additive α) 
goal: AddRightCancelMonoid (Additive α)

full_name: Multiplicative.rightCancelMonoid
code: instance Multiplicative.rightCancelMonoid [AddRightCancelMonoid α] :
    RightCancelMonoid (Multiplicative α) 
goal: RightCancelMonoid (Multiplicative α)

full_name: Additive.addCommMonoid
code: instance Additive.addCommMonoid [CommMonoid α] : AddCommMonoid (Additive α) 
goal: AddCommMonoid (Additive α)

full_name: Multiplicative.commMonoid
code: instance Multiplicative.commMonoid [AddCommMonoid α] : CommMonoid (Multiplicative α) 
goal: CommMonoid (Multiplicative α)

full_name: Additive.neg
code: instance Additive.neg [Inv α] : Neg (Additive α) 
goal: Neg (Additive α)

full_name: ofMul_inv
code: @[simp]
theorem ofMul_inv [Inv α] (x : α) : ofMul x⁻¹ = -ofMul x 
goal: Additive.ofMul x⁻¹ = -Additive.ofMul x

full_name: toMul_neg
code: @[simp]
theorem toMul_neg [Inv α] (x : Additive α) : toMul (-x) = (toMul x)⁻¹ 
goal: Additive.toMul (-x) = (Additive.toMul x)⁻¹

full_name: Multiplicative.inv
code: instance Multiplicative.inv [Neg α] : Inv (Multiplicative α) 
goal: Inv (Multiplicative α)

full_name: ofAdd_neg
code: @[simp]
theorem ofAdd_neg [Neg α] (x : α) : ofAdd (-x) = (ofAdd x)⁻¹ 
goal: Multiplicative.ofAdd (-x) = (Multiplicative.ofAdd x)⁻¹

full_name: toAdd_inv
code: @[simp]
theorem toAdd_inv [Neg α] (x : Multiplicative α) : toAdd x⁻¹ = -(toAdd x) 
goal: Multiplicative.toAdd x⁻¹ = -Multiplicative.toAdd x

full_name: Additive.sub
code: instance Additive.sub [Div α] : Sub (Additive α) 
goal: Sub (Additive α)

full_name: Multiplicative.div
code: instance Multiplicative.div [Sub α] : Div (Multiplicative α) 
goal: Div (Multiplicative α)

full_name: ofAdd_sub
code: @[simp]
theorem ofAdd_sub [Sub α] (x y : α) : ofAdd (x - y) = ofAdd x / ofAdd y 
goal: Multiplicative.ofAdd (x - y) = Multiplicative.ofAdd x / Multiplicative.ofAdd y

full_name: toAdd_div
code: @[simp]
theorem toAdd_div [Sub α] (x y : Multiplicative α) : toAdd (x / y) = toAdd x - toAdd y 
goal: Multiplicative.toAdd (x / y) = Multiplicative.toAdd x - Multiplicative.toAdd y

full_name: ofMul_div
code: @[simp]
theorem ofMul_div [Div α] (x y : α) : ofMul (x / y) = ofMul x - ofMul y 
goal: Additive.ofMul (x / y) = Additive.ofMul x - Additive.ofMul y

full_name: toMul_sub
code: @[simp]
theorem toMul_sub [Div α] (x y : Additive α) : toMul (x - y) = toMul x / toMul y 
goal: Additive.toMul (x - y) = Additive.toMul x / Additive.toMul y

full_name: Additive.involutiveNeg
code: instance Additive.involutiveNeg [InvolutiveInv α] : InvolutiveNeg (Additive α) 
goal: InvolutiveNeg (Additive α)

full_name: Multiplicative.involutiveInv
code: instance Multiplicative.involutiveInv [InvolutiveNeg α] : InvolutiveInv (Multiplicative α) 
goal: InvolutiveInv (Multiplicative α)

full_name: Additive.subNegMonoid
code: instance Additive.subNegMonoid [DivInvMonoid α] : SubNegMonoid (Additive α) 
goal: SubNegMonoid (Additive α)

full_name: Multiplicative.divInvMonoid
code: instance Multiplicative.divInvMonoid [SubNegMonoid α] : DivInvMonoid (Multiplicative α) 
goal: DivInvMonoid (Multiplicative α)

full_name: ofMul_zpow
code: @[simp]
theorem ofMul_zpow [DivInvMonoid α] (z : ℤ) (a : α) : ofMul (a ^ z) = z • ofMul a 
goal: Additive.ofMul (a ^ z) = z • Additive.ofMul a

full_name: toMul_zsmul
code: @[simp]
theorem toMul_zsmul [DivInvMonoid α] (z : ℤ) (a : Additive α) : toMul (z • a) = toMul a ^ z 
goal: Additive.toMul (z • a) = Additive.toMul a ^ z

full_name: ofAdd_zsmul
code: @[simp]
theorem ofAdd_zsmul [SubNegMonoid α] (z : ℤ) (a : α) : ofAdd (z • a) = ofAdd a ^ z 
goal: Multiplicative.ofAdd (z • a) = Multiplicative.ofAdd a ^ z

full_name: toAdd_zpow
code: @[simp]
theorem toAdd_zpow [SubNegMonoid α] (a : Multiplicative α) (z : ℤ) : toAdd (a ^ z) = z • toAdd a 
goal: Multiplicative.toAdd (a ^ z) = z • Multiplicative.toAdd a

full_name: Additive.subtractionMonoid
code: instance Additive.subtractionMonoid [DivisionMonoid α] : SubtractionMonoid (Additive α) 
goal: SubtractionMonoid (Additive α)

full_name: Multiplicative.divisionMonoid
code: instance Multiplicative.divisionMonoid [SubtractionMonoid α] : DivisionMonoid (Multiplicative α) 
goal: DivisionMonoid (Multiplicative α)

full_name: Additive.subtractionCommMonoid
code: instance Additive.subtractionCommMonoid [DivisionCommMonoid α] :
    SubtractionCommMonoid (Additive α) 
goal: SubtractionCommMonoid (Additive α)

full_name: Multiplicative.divisionCommMonoid
code: instance Multiplicative.divisionCommMonoid [SubtractionCommMonoid α] :
    DivisionCommMonoid (Multiplicative α) 
goal: DivisionCommMonoid (Multiplicative α)

full_name: Additive.addGroup
code: instance Additive.addGroup [Group α] : AddGroup (Additive α) 
goal: AddGroup (Additive α)

full_name: Multiplicative.group
code: instance Multiplicative.group [AddGroup α] : Group (Multiplicative α) 
goal: Group (Multiplicative α)

full_name: Additive.addCommGroup
code: instance Additive.addCommGroup [CommGroup α] : AddCommGroup (Additive α) 
goal: AddCommGroup (Additive α)

full_name: Multiplicative.commGroup
code: instance Multiplicative.commGroup [AddCommGroup α] : CommGroup (Multiplicative α) 
goal: CommGroup (Multiplicative α)

full_name: AddMonoidHom.toMultiplicative
code: /-- Reinterpret `α →+ β` as `Multiplicative α →* Multiplicative β`. -/
@[simps]
def AddMonoidHom.toMultiplicative [AddZeroClass α] [AddZeroClass β] :
    (α →+ β) ≃ (Multiplicative α →* Multiplicative β) 
goal: (α →+ β) ≃ (Multiplicative α →* Multiplicative β)

full_name: AddMonoidHom.toMultiplicative_apply_apply
code: /-- Reinterpret `α →+ β` as `Multiplicative α →* Multiplicative β`. -/
@[simps]
def AddMonoidHom.toMultiplicative [AddZeroClass α] [AddZeroClass β] :
    (α →+ β) ≃ (Multiplicative α →* Multiplicative β) 
goal: (AddMonoidHom.toMultiplicative f) a = Multiplicative.ofAdd (f (Multiplicative.toAdd a))

full_name: AddMonoidHom.toMultiplicative_symm_apply_apply
code: /-- Reinterpret `α →+ β` as `Multiplicative α →* Multiplicative β`. -/
@[simps]
def AddMonoidHom.toMultiplicative [AddZeroClass α] [AddZeroClass β] :
    (α →+ β) ≃ (Multiplicative α →* Multiplicative β) 
goal: (AddMonoidHom.toMultiplicative.symm f) a = Multiplicative.toAdd (f (Multiplicative.ofAdd a))

full_name: AddMonoidHom.coe_toMultiplicative
code: @[simp, norm_cast]
lemma AddMonoidHom.coe_toMultiplicative [AddZeroClass α] [AddZeroClass β] (f : α →+ β) :
    ⇑(toMultiplicative f) = ofAdd ∘ f ∘ toAdd 
goal: ⇑(AddMonoidHom.toMultiplicative f) = ⇑Multiplicative.ofAdd ∘ ⇑f ∘ ⇑Multiplicative.toAdd

full_name: MonoidHom.toAdditive
code: /-- Reinterpret `α →* β` as `Additive α →+ Additive β`. -/
@[simps]
def MonoidHom.toAdditive [MulOneClass α] [MulOneClass β] :
    (α →* β) ≃ (Additive α →+ Additive β) 
goal: (α →* β) ≃ (Additive α →+ Additive β)

full_name: MonoidHom.toAdditive_apply_apply
code: /-- Reinterpret `α →* β` as `Additive α →+ Additive β`. -/
@[simps]
def MonoidHom.toAdditive [MulOneClass α] [MulOneClass β] :
    (α →* β) ≃ (Additive α →+ Additive β) 
goal: (MonoidHom.toAdditive f) a = Additive.ofMul (f (Additive.toMul a))

full_name: MonoidHom.toAdditive_symm_apply_apply
code: /-- Reinterpret `α →* β` as `Additive α →+ Additive β`. -/
@[simps]
def MonoidHom.toAdditive [MulOneClass α] [MulOneClass β] :
    (α →* β) ≃ (Additive α →+ Additive β) 
goal: (MonoidHom.toAdditive.symm f) a = Additive.toMul (f (Additive.ofMul a))

full_name: MonoidHom.coe_toMultiplicative
code: @[simp, norm_cast]
lemma MonoidHom.coe_toMultiplicative [MulOneClass α] [MulOneClass β] (f : α →* β) :
    ⇑(toAdditive f) = ofMul ∘ f ∘ toMul 
goal: ⇑(MonoidHom.toAdditive f) = ⇑Additive.ofMul ∘ ⇑f ∘ ⇑Additive.toMul

full_name: AddMonoidHom.toMultiplicative'_apply_apply
code: /-- Reinterpret `Additive α →+ β` as `α →* Multiplicative β`. -/
@[simps]
def AddMonoidHom.toMultiplicative' [MulOneClass α] [AddZeroClass β] :
    (Additive α →+ β) ≃ (α →* Multiplicative β) 
goal: (AddMonoidHom.toMultiplicative' f) a = Multiplicative.ofAdd (f (Additive.ofMul a))

full_name: AddMonoidHom.toMultiplicative'_symm_apply_apply
code: /-- Reinterpret `Additive α →+ β` as `α →* Multiplicative β`. -/
@[simps]
def AddMonoidHom.toMultiplicative' [MulOneClass α] [AddZeroClass β] :
    (Additive α →+ β) ≃ (α →* Multiplicative β) 
goal: (AddMonoidHom.toMultiplicative'.symm f) a = Multiplicative.toAdd (f (Additive.toMul a))

full_name: AddMonoidHom.toMultiplicative'
code: /-- Reinterpret `Additive α →+ β` as `α →* Multiplicative β`. -/
@[simps]
def AddMonoidHom.toMultiplicative' [MulOneClass α] [AddZeroClass β] :
    (Additive α →+ β) ≃ (α →* Multiplicative β) 
goal: (Additive α →+ β) ≃ (α →* Multiplicative β)

full_name: AddMonoidHom.coe_toMultiplicative'
code: @[simp, norm_cast]
lemma AddMonoidHom.coe_toMultiplicative' [MulOneClass α] [AddZeroClass β] (f : Additive α →+ β) :
    ⇑(toMultiplicative' f) = ofAdd ∘ f ∘ ofMul 
goal: ⇑(AddMonoidHom.toMultiplicative' f) = ⇑Multiplicative.ofAdd ∘ ⇑f ∘ ⇑Additive.ofMul

full_name: MonoidHom.toAdditive'
code: /-- Reinterpret `α →* Multiplicative β` as `Additive α →+ β`. -/
@[simps!]
def MonoidHom.toAdditive' [MulOneClass α] [AddZeroClass β] :
    (α →* Multiplicative β) ≃ (Additive α →+ β) 
goal: (α →* Multiplicative β) ≃ (Additive α →+ β)

full_name: MonoidHom.toAdditive'_apply_apply
code: /-- Reinterpret `α →* Multiplicative β` as `Additive α →+ β`. -/
@[simps!]
def MonoidHom.toAdditive' [MulOneClass α] [AddZeroClass β] :
    (α →* Multiplicative β) ≃ (Additive α →+ β) 
goal: ∀ (a : α →* Multiplicative β) (a_1 : Additive α),
  (MonoidHom.toAdditive' a) a_1 = Multiplicative.toAdd (a (Additive.toMul a_1))

full_name: MonoidHom.toAdditive'_symm_apply_apply
code: /-- Reinterpret `α →* Multiplicative β` as `Additive α →+ β`. -/
@[simps!]
def MonoidHom.toAdditive' [MulOneClass α] [AddZeroClass β] :
    (α →* Multiplicative β) ≃ (Additive α →+ β) 
goal: ∀ (a : Additive α →+ β) (a_1 : α), (MonoidHom.toAdditive'.symm a) a_1 = Multiplicative.ofAdd (a (Additive.ofMul a_1))

full_name: MonoidHom.coe_toAdditive'
code: @[simp, norm_cast]
lemma MonoidHom.coe_toAdditive' [MulOneClass α] [AddZeroClass β] (f : α →* Multiplicative β) :
    ⇑(toAdditive' f) = toAdd ∘ f ∘ toMul 
goal: ⇑(MonoidHom.toAdditive' f) = ⇑Multiplicative.toAdd ∘ ⇑f ∘ ⇑Additive.toMul

full_name: AddMonoidHom.toMultiplicative''_symm_apply_apply
code: /-- Reinterpret `α →+ Additive β` as `Multiplicative α →* β`. -/
@[simps]
def AddMonoidHom.toMultiplicative'' [AddZeroClass α] [MulOneClass β] :
    (α →+ Additive β) ≃ (Multiplicative α →* β) 
goal: (AddMonoidHom.toMultiplicative''.symm f) a = Additive.ofMul (f (Multiplicative.ofAdd a))

full_name: AddMonoidHom.toMultiplicative''
code: /-- Reinterpret `α →+ Additive β` as `Multiplicative α →* β`. -/
@[simps]
def AddMonoidHom.toMultiplicative'' [AddZeroClass α] [MulOneClass β] :
    (α →+ Additive β) ≃ (Multiplicative α →* β) 
goal: (α →+ Additive β) ≃ (Multiplicative α →* β)

full_name: AddMonoidHom.toMultiplicative''_apply_apply
code: /-- Reinterpret `α →+ Additive β` as `Multiplicative α →* β`. -/
@[simps]
def AddMonoidHom.toMultiplicative'' [AddZeroClass α] [MulOneClass β] :
    (α →+ Additive β) ≃ (Multiplicative α →* β) 
goal: (AddMonoidHom.toMultiplicative'' f) a = Additive.toMul (f (Multiplicative.toAdd a))

full_name: AddMonoidHom.coe_toMultiplicative''
code: @[simp, norm_cast]
lemma AddMonoidHom.coe_toMultiplicative'' [AddZeroClass α] [MulOneClass β] (f : α →+ Additive β) :
    ⇑(toMultiplicative'' f) = toMul ∘ f ∘ toAdd 
goal: ⇑(AddMonoidHom.toMultiplicative'' f) = ⇑Additive.toMul ∘ ⇑f ∘ ⇑Multiplicative.toAdd

full_name: MonoidHom.toAdditive''
code: /-- Reinterpret `Multiplicative α →* β` as `α →+ Additive β`. -/
@[simps!]
def MonoidHom.toAdditive'' [AddZeroClass α] [MulOneClass β] :
    (Multiplicative α →* β) ≃ (α →+ Additive β) 
goal: (Multiplicative α →* β) ≃ (α →+ Additive β)

full_name: MonoidHom.toAdditive''_symm_apply_apply
code: /-- Reinterpret `Multiplicative α →* β` as `α →+ Additive β`. -/
@[simps!]
def MonoidHom.toAdditive'' [AddZeroClass α] [MulOneClass β] :
    (Multiplicative α →* β) ≃ (α →+ Additive β) 
goal: ∀ (a : α →+ Additive β) (a_1 : Multiplicative α),
  (MonoidHom.toAdditive''.symm a) a_1 = Additive.toMul (a (Multiplicative.toAdd a_1))

full_name: MonoidHom.toAdditive''_apply_apply
code: /-- Reinterpret `Multiplicative α →* β` as `α →+ Additive β`. -/
@[simps!]
def MonoidHom.toAdditive'' [AddZeroClass α] [MulOneClass β] :
    (Multiplicative α →* β) ≃ (α →+ Additive β) 
goal: ∀ (a : Multiplicative α →* β) (a_1 : α), (MonoidHom.toAdditive'' a) a_1 = Additive.ofMul (a (Multiplicative.ofAdd a_1))

full_name: MonoidHom.coe_toAdditive''
code: @[simp, norm_cast]
lemma MonoidHom.coe_toAdditive'' [AddZeroClass α] [MulOneClass β] (f : Multiplicative α →* β) :
    ⇑(toAdditive'' f) = ofMul ∘ f ∘ ofAdd 
goal: ⇑(MonoidHom.toAdditive'' f) = ⇑Additive.ofMul ∘ ⇑f ∘ ⇑Multiplicative.ofAdd

full_name: Additive.coeToFun
code: /-- If `α` has some multiplicative structure and coerces to a function,
then `Additive α` should also coerce to the same function.

This allows `Additive` to be used on bundled function types with a multiplicative structure, which
is often used for composition, without affecting the behavior of the function itself.
-/
instance Additive.coeToFun {α : Type*} {β : α → Sort*} [CoeFun α β] :
    CoeFun (Additive α) fun a => β (toMul a) 
goal: CoeFun (Additive α) fun a => β (Additive.toMul a)

full_name: Multiplicative.coeToFun
code: /-- If `α` has some additive structure and coerces to a function,
then `Multiplicative α` should also coerce to the same function.

This allows `Multiplicative` to be used on bundled function types with an additive structure, which
is often used for composition, without affecting the behavior of the function itself.
-/
instance Multiplicative.coeToFun {α : Type*} {β : α → Sort*} [CoeFun α β] :
    CoeFun (Multiplicative α) fun a => β (toAdd a) 
goal: CoeFun (Multiplicative α) fun a => β (Multiplicative.toAdd a)