File: Mathlib/Algebra/Group/Units/Equiv.lean

full_name: val_toAddUnits_apply
code: /-- A group is isomorphic to its group of units. -/
@[to_additive (attr := simps apply_val symm_apply)
"An additive group is isomorphic to its group of additive units"]
def toUnits [Group G] : G ≃* Gˣ 
goal: ↑(toAddUnits x) = x

full_name: val_toUnits_apply
code: /-- A group is isomorphic to its group of units. -/
@[to_additive (attr := simps apply_val symm_apply)
"An additive group is isomorphic to its group of additive units"]
def toUnits [Group G] : G ≃* Gˣ 
goal: ↑(toUnits x) = x

full_name: toUnits
code: /-- A group is isomorphic to its group of units. -/
@[to_additive (attr := simps apply_val symm_apply)
"An additive group is isomorphic to its group of additive units"]
def toUnits [Group G] : G ≃* Gˣ 
goal: G ≃* Gˣ

full_name: toUnits_symm_apply
code: /-- A group is isomorphic to its group of units. -/
@[to_additive (attr := simps apply_val symm_apply)
"An additive group is isomorphic to its group of additive units"]
def toUnits [Group G] : G ≃* Gˣ 
goal: toUnits.symm x = ↑x

full_name: toAddUnits
code: /-- A group is isomorphic to its group of units. -/
@[to_additive (attr := simps apply_val symm_apply)
"An additive group is isomorphic to its group of additive units"]
def toUnits [Group G] : G ≃* Gˣ 
goal: G ≃+ AddUnits G

full_name: toAddUnits_symm_apply
code: /-- A group is isomorphic to its group of units. -/
@[to_additive (attr := simps apply_val symm_apply)
"An additive group is isomorphic to its group of additive units"]
def toUnits [Group G] : G ≃* Gˣ 
goal: toAddUnits.symm x = ↑x

full_name: toAddUnits_val_apply
code: @[to_additive (attr := simp)]
lemma toUnits_val_apply {G : Type*} [Group G] (x : Gˣ) : toUnits (x : G) = x 
goal: toAddUnits ↑x = x

full_name: toUnits_val_apply
code: @[to_additive (attr := simp)]
lemma toUnits_val_apply {G : Type*} [Group G] (x : Gˣ) : toUnits (x : G) = x 
goal: toUnits ↑x = x

full_name: Units.mapEquiv
code: /-- A multiplicative equivalence of monoids defines a multiplicative equivalence
of their groups of units. -/
def mapEquiv (h : M ≃* N) : Mˣ ≃* Nˣ 
goal: Mˣ ≃* Nˣ

full_name: Units.mapEquiv_symm
code: @[simp]
theorem mapEquiv_symm (h : M ≃* N) : (mapEquiv h).symm = mapEquiv h.symm 
goal: (Units.mapEquiv h).symm = Units.mapEquiv h.symm

full_name: Units.coe_mapEquiv
code: @[simp]
theorem coe_mapEquiv (h : M ≃* N) (x : Mˣ) : (mapEquiv h x : N) = h x 
goal: ↑((Units.mapEquiv h) x) = h ↑x

full_name: AddUnits.addLeft_apply
code: /-- Left multiplication by a unit of a monoid is a permutation of the underlying type. -/
@[to_additive (attr := simps (config := .asFn) apply)
  "Left addition of an additive unit is a permutation of the underlying type."]
def mulLeft (u : Mˣ) : Equiv.Perm M 
goal: ⇑u.addLeft = fun x => ↑u + x

full_name: Units.mulLeft
code: /-- Left multiplication by a unit of a monoid is a permutation of the underlying type. -/
@[to_additive (attr := simps (config := .asFn) apply)
  "Left addition of an additive unit is a permutation of the underlying type."]
def mulLeft (u : Mˣ) : Equiv.Perm M 
goal: Equiv.Perm M

full_name: AddUnits.addLeft
code: /-- Left multiplication by a unit of a monoid is a permutation of the underlying type. -/
@[to_additive (attr := simps (config := .asFn) apply)
  "Left addition of an additive unit is a permutation of the underlying type."]
def mulLeft (u : Mˣ) : Equiv.Perm M 
goal: Equiv.Perm M

full_name: Units.mulLeft_apply
code: /-- Left multiplication by a unit of a monoid is a permutation of the underlying type. -/
@[to_additive (attr := simps (config := .asFn) apply)
  "Left addition of an additive unit is a permutation of the underlying type."]
def mulLeft (u : Mˣ) : Equiv.Perm M 
goal: ⇑u.mulLeft = fun x => ↑u * x

full_name: Units.mulLeft_symm
code: @[to_additive (attr := simp)]
theorem mulLeft_symm (u : Mˣ) : u.mulLeft.symm = u⁻¹.mulLeft 
goal: Equiv.symm u.mulLeft = u⁻¹.mulLeft

full_name: AddUnits.addLeft_symm
code: @[to_additive (attr := simp)]
theorem mulLeft_symm (u : Mˣ) : u.mulLeft.symm = u⁻¹.mulLeft 
goal: Equiv.symm u.addLeft = (-u).addLeft

full_name: Units.mulLeft_bijective
code: @[to_additive]
theorem mulLeft_bijective (a : Mˣ) : Function.Bijective ((a * ·) : M → M) 
goal: Function.Bijective fun x => ↑a * x

full_name: AddUnits.addLeft_bijective
code: @[to_additive]
theorem mulLeft_bijective (a : Mˣ) : Function.Bijective ((a * ·) : M → M) 
goal: Function.Bijective fun x => ↑a + x

full_name: Units.mulRight
code: /-- Right multiplication by a unit of a monoid is a permutation of the underlying type. -/
@[to_additive (attr := simps (config := .asFn) apply)
"Right addition of an additive unit is a permutation of the underlying type."]
def mulRight (u : Mˣ) : Equiv.Perm M 
goal: Equiv.Perm M

full_name: Units.mulRight_apply
code: /-- Right multiplication by a unit of a monoid is a permutation of the underlying type. -/
@[to_additive (attr := simps (config := .asFn) apply)
"Right addition of an additive unit is a permutation of the underlying type."]
def mulRight (u : Mˣ) : Equiv.Perm M 
goal: ⇑u.mulRight = fun x => x * ↑u

full_name: AddUnits.addRight
code: /-- Right multiplication by a unit of a monoid is a permutation of the underlying type. -/
@[to_additive (attr := simps (config := .asFn) apply)
"Right addition of an additive unit is a permutation of the underlying type."]
def mulRight (u : Mˣ) : Equiv.Perm M 
goal: Equiv.Perm M

full_name: AddUnits.addRight_apply
code: /-- Right multiplication by a unit of a monoid is a permutation of the underlying type. -/
@[to_additive (attr := simps (config := .asFn) apply)
"Right addition of an additive unit is a permutation of the underlying type."]
def mulRight (u : Mˣ) : Equiv.Perm M 
goal: ⇑u.addRight = fun x => x + ↑u

full_name: Units.mulRight_symm
code: @[to_additive (attr := simp)]
theorem mulRight_symm (u : Mˣ) : u.mulRight.symm = u⁻¹.mulRight 
goal: Equiv.symm u.mulRight = u⁻¹.mulRight

full_name: AddUnits.addRight_symm
code: @[to_additive (attr := simp)]
theorem mulRight_symm (u : Mˣ) : u.mulRight.symm = u⁻¹.mulRight 
goal: Equiv.symm u.addRight = (-u).addRight

full_name: AddUnits.addRight_bijective
code: @[to_additive]
theorem mulRight_bijective (a : Mˣ) : Function.Bijective ((· * a) : M → M) 
goal: Function.Bijective fun x => x + ↑a

full_name: Units.mulRight_bijective
code: @[to_additive]
theorem mulRight_bijective (a : Mˣ) : Function.Bijective ((· * a) : M → M) 
goal: Function.Bijective fun x => x * ↑a

full_name: Equiv.mulLeft
code: /-- Left multiplication in a `Group` is a permutation of the underlying type. -/
@[to_additive "Left addition in an `AddGroup` is a permutation of the underlying type."]
protected def mulLeft (a : G) : Perm G 
goal: Equiv.Perm G

full_name: Equiv.addLeft
code: /-- Left multiplication in a `Group` is a permutation of the underlying type. -/
@[to_additive "Left addition in an `AddGroup` is a permutation of the underlying type."]
protected def mulLeft (a : G) : Perm G 
goal: Equiv.Perm G

full_name: Equiv.coe_mulLeft
code: @[to_additive (attr := simp)]
theorem coe_mulLeft (a : G) : ⇑(Equiv.mulLeft a) = (a * ·) 
goal: ⇑(Equiv.mulLeft a) = fun x => a * x

full_name: Equiv.coe_addLeft
code: @[to_additive (attr := simp)]
theorem coe_mulLeft (a : G) : ⇑(Equiv.mulLeft a) = (a * ·) 
goal: ⇑(Equiv.addLeft a) = fun x => a + x

full_name: Equiv.addLeft_symm_apply
code: /-- Extra simp lemma that `dsimp` can use. `simp` will never use this. -/
@[to_additive "Extra simp lemma that `dsimp` can use. `simp` will never use this.",
  simp, nolint simpNF]
theorem mulLeft_symm_apply (a : G) : ((Equiv.mulLeft a).symm : G → G) = (a⁻¹ * ·) 
goal: ⇑(Equiv.symm (Equiv.addLeft a)) = fun x => -a + x

full_name: Equiv.mulLeft_symm_apply
code: /-- Extra simp lemma that `dsimp` can use. `simp` will never use this. -/
@[to_additive "Extra simp lemma that `dsimp` can use. `simp` will never use this.",
  simp, nolint simpNF]
theorem mulLeft_symm_apply (a : G) : ((Equiv.mulLeft a).symm : G → G) = (a⁻¹ * ·) 
goal: ⇑(Equiv.symm (Equiv.mulLeft a)) = fun x => a⁻¹ * x

full_name: Equiv.mulLeft_symm
code: @[to_additive (attr := simp)]
theorem mulLeft_symm (a : G) : (Equiv.mulLeft a).symm = Equiv.mulLeft a⁻¹ 
goal: Equiv.symm (Equiv.mulLeft a) = Equiv.mulLeft a⁻¹

full_name: Equiv.addLeft_symm
code: @[to_additive (attr := simp)]
theorem mulLeft_symm (a : G) : (Equiv.mulLeft a).symm = Equiv.mulLeft a⁻¹ 
goal: Equiv.symm (Equiv.addLeft a) = Equiv.addLeft (-a)

full_name: Group.mulLeft_bijective
code: @[to_additive]
theorem _root_.Group.mulLeft_bijective (a : G) : Function.Bijective (a * ·) 
goal: Function.Bijective fun x => a * x

full_name: AddGroup.addLeft_bijective
code: @[to_additive]
theorem _root_.Group.mulLeft_bijective (a : G) : Function.Bijective (a * ·) 
goal: Function.Bijective fun x => a + x

full_name: Equiv.mulRight
code: /-- Right multiplication in a `Group` is a permutation of the underlying type. -/
@[to_additive "Right addition in an `AddGroup` is a permutation of the underlying type."]
protected def mulRight (a : G) : Perm G 
goal: Equiv.Perm G

full_name: Equiv.addRight
code: /-- Right multiplication in a `Group` is a permutation of the underlying type. -/
@[to_additive "Right addition in an `AddGroup` is a permutation of the underlying type."]
protected def mulRight (a : G) : Perm G 
goal: Equiv.Perm G

full_name: Equiv.coe_mulRight
code: @[to_additive (attr := simp)]
theorem coe_mulRight (a : G) : ⇑(Equiv.mulRight a) = fun x => x * a 
goal: ⇑(Equiv.mulRight a) = fun x => x * a

full_name: Equiv.coe_addRight
code: @[to_additive (attr := simp)]
theorem coe_mulRight (a : G) : ⇑(Equiv.mulRight a) = fun x => x * a 
goal: ⇑(Equiv.addRight a) = fun x => x + a

full_name: Equiv.addRight_symm
code: @[to_additive (attr := simp)]
theorem mulRight_symm (a : G) : (Equiv.mulRight a).symm = Equiv.mulRight a⁻¹ 
goal: Equiv.symm (Equiv.addRight a) = Equiv.addRight (-a)

full_name: Equiv.mulRight_symm
code: @[to_additive (attr := simp)]
theorem mulRight_symm (a : G) : (Equiv.mulRight a).symm = Equiv.mulRight a⁻¹ 
goal: Equiv.symm (Equiv.mulRight a) = Equiv.mulRight a⁻¹

full_name: Equiv.addRight_symm_apply
code: /-- Extra simp lemma that `dsimp` can use. `simp` will never use this. -/
@[to_additive "Extra simp lemma that `dsimp` can use. `simp` will never use this.",
  simp, nolint simpNF]
theorem mulRight_symm_apply (a : G) : ((Equiv.mulRight a).symm : G → G) = fun x => x * a⁻¹ 
goal: ⇑(Equiv.symm (Equiv.addRight a)) = fun x => x + -a

full_name: Equiv.mulRight_symm_apply
code: /-- Extra simp lemma that `dsimp` can use. `simp` will never use this. -/
@[to_additive "Extra simp lemma that `dsimp` can use. `simp` will never use this.",
  simp, nolint simpNF]
theorem mulRight_symm_apply (a : G) : ((Equiv.mulRight a).symm : G → G) = fun x => x * a⁻¹ 
goal: ⇑(Equiv.symm (Equiv.mulRight a)) = fun x => x * a⁻¹

full_name: Group.mulRight_bijective
code: @[to_additive]
theorem _root_.Group.mulRight_bijective (a : G) : Function.Bijective (· * a) 
goal: Function.Bijective fun x => x * a

full_name: AddGroup.addRight_bijective
code: @[to_additive]
theorem _root_.Group.mulRight_bijective (a : G) : Function.Bijective (· * a) 
goal: Function.Bijective fun x => x + a

full_name: Equiv.divLeft_apply
code: /-- A version of `Equiv.mulLeft a b⁻¹` that is defeq to `a / b`. -/
@[to_additive (attr := simps) " A version of `Equiv.addLeft a (-b)` that is defeq to `a - b`. "]
protected def divLeft (a : G) : G ≃ G 
goal: (Equiv.divLeft a) b = a / b

full_name: Equiv.subLeft_symm_apply
code: /-- A version of `Equiv.mulLeft a b⁻¹` that is defeq to `a / b`. -/
@[to_additive (attr := simps) " A version of `Equiv.addLeft a (-b)` that is defeq to `a - b`. "]
protected def divLeft (a : G) : G ≃ G 
goal: (Equiv.subLeft a).symm b = -b + a

full_name: Equiv.subLeft_apply
code: /-- A version of `Equiv.mulLeft a b⁻¹` that is defeq to `a / b`. -/
@[to_additive (attr := simps) " A version of `Equiv.addLeft a (-b)` that is defeq to `a - b`. "]
protected def divLeft (a : G) : G ≃ G 
goal: (Equiv.subLeft a) b = a - b

full_name: Equiv.divLeft_symm_apply
code: /-- A version of `Equiv.mulLeft a b⁻¹` that is defeq to `a / b`. -/
@[to_additive (attr := simps) " A version of `Equiv.addLeft a (-b)` that is defeq to `a - b`. "]
protected def divLeft (a : G) : G ≃ G 
goal: (Equiv.divLeft a).symm b = b⁻¹ * a

full_name: Equiv.divLeft
code: /-- A version of `Equiv.mulLeft a b⁻¹` that is defeq to `a / b`. -/
@[to_additive (attr := simps) " A version of `Equiv.addLeft a (-b)` that is defeq to `a - b`. "]
protected def divLeft (a : G) : G ≃ G 
goal: G ≃ G

full_name: Equiv.subLeft
code: /-- A version of `Equiv.mulLeft a b⁻¹` that is defeq to `a / b`. -/
@[to_additive (attr := simps) " A version of `Equiv.addLeft a (-b)` that is defeq to `a - b`. "]
protected def divLeft (a : G) : G ≃ G 
goal: G ≃ G

full_name: Equiv.subLeft_eq_neg_trans_addLeft
code: @[to_additive]
theorem divLeft_eq_inv_trans_mulLeft (a : G) :
    Equiv.divLeft a = (Equiv.inv G).trans (Equiv.mulLeft a) 
goal: Equiv.subLeft a = Equiv.trans (Equiv.neg G) (Equiv.addLeft a)

full_name: Equiv.divLeft_eq_inv_trans_mulLeft
code: @[to_additive]
theorem divLeft_eq_inv_trans_mulLeft (a : G) :
    Equiv.divLeft a = (Equiv.inv G).trans (Equiv.mulLeft a) 
goal: Equiv.divLeft a = Equiv.trans (Equiv.inv G) (Equiv.mulLeft a)

full_name: Equiv.divRight
code: /-- A version of `Equiv.mulRight a⁻¹ b` that is defeq to `b / a`. -/
@[to_additive (attr := simps) " A version of `Equiv.addRight (-a) b` that is defeq to `b - a`. "]
protected def divRight (a : G) : G ≃ G 
goal: G ≃ G

full_name: Equiv.subRight_symm_apply
code: /-- A version of `Equiv.mulRight a⁻¹ b` that is defeq to `b / a`. -/
@[to_additive (attr := simps) " A version of `Equiv.addRight (-a) b` that is defeq to `b - a`. "]
protected def divRight (a : G) : G ≃ G 
goal: (Equiv.subRight a).symm b = b + a

full_name: Equiv.subRight
code: /-- A version of `Equiv.mulRight a⁻¹ b` that is defeq to `b / a`. -/
@[to_additive (attr := simps) " A version of `Equiv.addRight (-a) b` that is defeq to `b - a`. "]
protected def divRight (a : G) : G ≃ G 
goal: G ≃ G

full_name: Equiv.subRight_apply
code: /-- A version of `Equiv.mulRight a⁻¹ b` that is defeq to `b / a`. -/
@[to_additive (attr := simps) " A version of `Equiv.addRight (-a) b` that is defeq to `b - a`. "]
protected def divRight (a : G) : G ≃ G 
goal: (Equiv.subRight a) b = b - a

full_name: Equiv.divRight_symm_apply
code: /-- A version of `Equiv.mulRight a⁻¹ b` that is defeq to `b / a`. -/
@[to_additive (attr := simps) " A version of `Equiv.addRight (-a) b` that is defeq to `b - a`. "]
protected def divRight (a : G) : G ≃ G 
goal: (Equiv.divRight a).symm b = b * a

full_name: Equiv.divRight_apply
code: /-- A version of `Equiv.mulRight a⁻¹ b` that is defeq to `b / a`. -/
@[to_additive (attr := simps) " A version of `Equiv.addRight (-a) b` that is defeq to `b - a`. "]
protected def divRight (a : G) : G ≃ G 
goal: (Equiv.divRight a) b = b / a

full_name: Equiv.divRight_eq_mulRight_inv
code: @[to_additive]
theorem divRight_eq_mulRight_inv (a : G) : Equiv.divRight a = Equiv.mulRight a⁻¹ 
goal: Equiv.divRight a = Equiv.mulRight a⁻¹

full_name: Equiv.subRight_eq_addRight_neg
code: @[to_additive]
theorem divRight_eq_mulRight_inv (a : G) : Equiv.divRight a = Equiv.mulRight a⁻¹ 
goal: Equiv.subRight a = Equiv.addRight (-a)

full_name: unitsEquivProdSubtype
code: /-- The `αˣ` type is equivalent to a subtype of `α × α`. -/
@[simps]
def unitsEquivProdSubtype [Monoid α] : αˣ ≃ {p : α × α // p.1 * p.2 = 1 ∧ p.2 * p.1 = 1} 
goal: αˣ ≃ { p // p.1 * p.2 = 1 ∧ p.2 * p.1 = 1 }

full_name: val_inv_unitsEquivProdSubtype_symm_apply
code: /-- The `αˣ` type is equivalent to a subtype of `α × α`. -/
@[simps]
def unitsEquivProdSubtype [Monoid α] : αˣ ≃ {p : α × α // p.1 * p.2 = 1 ∧ p.2 * p.1 = 1} 
goal: ↑((unitsEquivProdSubtype α).symm p)⁻¹ = (↑p).2

full_name: unitsEquivProdSubtype_apply_coe
code: /-- The `αˣ` type is equivalent to a subtype of `α × α`. -/
@[simps]
def unitsEquivProdSubtype [Monoid α] : αˣ ≃ {p : α × α // p.1 * p.2 = 1 ∧ p.2 * p.1 = 1} 
goal: ↑((unitsEquivProdSubtype α) u) = (↑u, ↑u⁻¹)

full_name: val_unitsEquivProdSubtype_symm_apply
code: /-- The `αˣ` type is equivalent to a subtype of `α × α`. -/
@[simps]
def unitsEquivProdSubtype [Monoid α] : αˣ ≃ {p : α × α // p.1 * p.2 = 1 ∧ p.2 * p.1 = 1} 
goal: ↑((unitsEquivProdSubtype α).symm p) = (↑p).1

full_name: MulEquiv.inv
code: /-- In a `DivisionCommMonoid`, `Equiv.inv` is a `MulEquiv`. There is a variant of this
`MulEquiv.inv' G : G ≃* Gᵐᵒᵖ` for the non-commutative case. -/
@[to_additive (attr := simps apply)
  "When the `AddGroup` is commutative, `Equiv.neg` is an `AddEquiv`."]
def MulEquiv.inv (G : Type*) [DivisionCommMonoid G] : G ≃* G 
goal: G ≃* G

full_name: MulEquiv.inv_apply
code: /-- In a `DivisionCommMonoid`, `Equiv.inv` is a `MulEquiv`. There is a variant of this
`MulEquiv.inv' G : G ≃* Gᵐᵒᵖ` for the non-commutative case. -/
@[to_additive (attr := simps apply)
  "When the `AddGroup` is commutative, `Equiv.neg` is an `AddEquiv`."]
def MulEquiv.inv (G : Type*) [DivisionCommMonoid G] : G ≃* G 
goal: ∀ (a : G), (MulEquiv.inv G) a = a⁻¹

full_name: AddEquiv.neg_apply
code: /-- In a `DivisionCommMonoid`, `Equiv.inv` is a `MulEquiv`. There is a variant of this
`MulEquiv.inv' G : G ≃* Gᵐᵒᵖ` for the non-commutative case. -/
@[to_additive (attr := simps apply)
  "When the `AddGroup` is commutative, `Equiv.neg` is an `AddEquiv`."]
def MulEquiv.inv (G : Type*) [DivisionCommMonoid G] : G ≃* G 
goal: ∀ (a : G), (AddEquiv.neg G) a = -a

full_name: AddEquiv.neg
code: /-- In a `DivisionCommMonoid`, `Equiv.inv` is a `MulEquiv`. There is a variant of this
`MulEquiv.inv' G : G ≃* Gᵐᵒᵖ` for the non-commutative case. -/
@[to_additive (attr := simps apply)
  "When the `AddGroup` is commutative, `Equiv.neg` is an `AddEquiv`."]
def MulEquiv.inv (G : Type*) [DivisionCommMonoid G] : G ≃* G 
goal: G ≃+ G

full_name: AddEquiv.neg_symm
code: @[to_additive (attr := simp)]
theorem MulEquiv.inv_symm (G : Type*) [DivisionCommMonoid G] :
    (MulEquiv.inv G).symm = MulEquiv.inv G 
goal: (AddEquiv.neg G).symm = AddEquiv.neg G

full_name: MulEquiv.inv_symm
code: @[to_additive (attr := simp)]
theorem MulEquiv.inv_symm (G : Type*) [DivisionCommMonoid G] :
    (MulEquiv.inv G).symm = MulEquiv.inv G 
goal: (MulEquiv.inv G).symm = MulEquiv.inv G

full_name: AddEquiv.map_isAddUnit_iff
code: @[to_additive]
protected
theorem MulEquiv.map_isUnit_iff {M N} [Monoid M] [Monoid N] [EquivLike F M N] [MonoidHomClass F M N]
    (f : F) {m : M} : IsUnit (f m) ↔ IsUnit m 
goal: IsAddUnit (f m) ↔ IsAddUnit m

full_name: MulEquiv.map_isUnit_iff
code: @[to_additive]
protected
theorem MulEquiv.map_isUnit_iff {M N} [Monoid M] [Monoid N] [EquivLike F M N] [MonoidHomClass F M N]
    (f : F) {m : M} : IsUnit (f m) ↔ IsUnit m 
goal: IsUnit (f m) ↔ IsUnit m