File: Mathlib/GroupTheory/Submonoid/Inverses.lean

full_name: Submonoid.instGroupSubtypeMemSubmonoid
code: @[to_additive]
noncomputable instance [Monoid M] : Group (IsUnit.submonoid M) 
goal: Group ↥(IsUnit.submonoid M)

full_name: AddSubmonoid.instAddGroupSubtypeMemAddSubmonoid
code: @[to_additive]
noncomputable instance [Monoid M] : Group (IsUnit.submonoid M) 
goal: AddGroup ↥(IsAddUnit.addSubmonoid M)

full_name: Submonoid.instCommGroupSubtypeMemSubmonoid
code: @[to_additive]
noncomputable instance [CommMonoid M] : CommGroup (IsUnit.submonoid M) 
goal: CommGroup ↥(IsUnit.submonoid M)

full_name: AddSubmonoid.instAddCommGroupSubtypeMemAddSubmonoid
code: @[to_additive]
noncomputable instance [CommMonoid M] : CommGroup (IsUnit.submonoid M) 
goal: AddCommGroup ↥(IsAddUnit.addSubmonoid M)

full_name: AddSubmonoid.IsUnit.Submonoid.coe_neg
code: @[to_additive]
theorem IsUnit.Submonoid.coe_inv [Monoid M] (x : IsUnit.submonoid M) :
    ↑x⁻¹ = (↑x.prop.unit⁻¹ : M) 
goal: ↑(-x) = ↑(-IsAddUnit.addUnit ⋯)

full_name: Submonoid.IsUnit.Submonoid.coe_inv
code: @[to_additive]
theorem IsUnit.Submonoid.coe_inv [Monoid M] (x : IsUnit.submonoid M) :
    ↑x⁻¹ = (↑x.prop.unit⁻¹ : M) 
goal: ↑x⁻¹ = ↑(IsUnit.unit ⋯)⁻¹

full_name: Submonoid.leftInv
code: /-- `S.leftInv` is the submonoid containing all the left inverses of `S`. -/
@[to_additive
      "`S.leftNeg` is the additive submonoid containing all the left additive inverses of `S`."]
def leftInv : Submonoid M 
goal: Submonoid M

full_name: AddSubmonoid.leftNeg
code: /-- `S.leftInv` is the submonoid containing all the left inverses of `S`. -/
@[to_additive
      "`S.leftNeg` is the additive submonoid containing all the left additive inverses of `S`."]
def leftInv : Submonoid M 
goal: AddSubmonoid M

full_name: Submonoid.leftInv_leftInv_le
code: @[to_additive]
theorem leftInv_leftInv_le : S.leftInv.leftInv ≤ S 
goal: S.leftInv.leftInv ≤ S

full_name: AddSubmonoid.leftNeg_leftNeg_le
code: @[to_additive]
theorem leftInv_leftInv_le : S.leftInv.leftInv ≤ S 
goal: S.leftNeg.leftNeg ≤ S

full_name: AddSubmonoid.addUnit_mem_leftNeg
code: @[to_additive]
theorem unit_mem_leftInv (x : Mˣ) (hx : (x : M) ∈ S) : ((x⁻¹ : _) : M) ∈ S.leftInv 
goal: ↑(-x) ∈ S.leftNeg

full_name: Submonoid.unit_mem_leftInv
code: @[to_additive]
theorem unit_mem_leftInv (x : Mˣ) (hx : (x : M) ∈ S) : ((x⁻¹ : _) : M) ∈ S.leftInv 
goal: ↑x⁻¹ ∈ S.leftInv

full_name: Submonoid.leftInv_leftInv_eq
code: @[to_additive]
theorem leftInv_leftInv_eq (hS : S ≤ IsUnit.submonoid M) : S.leftInv.leftInv = S 
goal: S.leftInv.leftInv = S

full_name: AddSubmonoid.leftNeg_leftNeg_eq
code: @[to_additive]
theorem leftInv_leftInv_eq (hS : S ≤ IsUnit.submonoid M) : S.leftInv.leftInv = S 
goal: S.leftNeg.leftNeg = S

full_name: Submonoid.fromLeftInv
code: /-- The function from `S.leftInv` to `S` sending an element to its right inverse in `S`.
This is a `MonoidHom` when `M` is commutative. -/
@[to_additive
      "The function from `S.leftAdd` to `S` sending an element to its right additive
inverse in `S`. This is an `AddMonoidHom` when `M` is commutative."]
noncomputable def fromLeftInv : S.leftInv → S 
goal: ↥S.leftInv → ↥S

full_name: AddSubmonoid.fromLeftNeg
code: /-- The function from `S.leftInv` to `S` sending an element to its right inverse in `S`.
This is a `MonoidHom` when `M` is commutative. -/
@[to_additive
      "The function from `S.leftAdd` to `S` sending an element to its right additive
inverse in `S`. This is an `AddMonoidHom` when `M` is commutative."]
noncomputable def fromLeftInv : S.leftInv → S 
goal: ↥S.leftNeg → ↥S

full_name: Submonoid.mul_fromLeftInv
code: @[to_additive (attr := simp)]
theorem mul_fromLeftInv (x : S.leftInv) : (x : M) * S.fromLeftInv x = 1 
goal: ↑x * ↑(S.fromLeftInv x) = 1

full_name: AddSubmonoid.add_fromLeftNeg
code: @[to_additive (attr := simp)]
theorem mul_fromLeftInv (x : S.leftInv) : (x : M) * S.fromLeftInv x = 1 
goal: ↑x + ↑(S.fromLeftNeg x) = 0

full_name: Submonoid.fromLeftInv_one
code: @[to_additive (attr := simp)]
theorem fromLeftInv_one : S.fromLeftInv 1 = 1 
goal: S.fromLeftInv 1 = 1

full_name: AddSubmonoid.fromLeftNeg_zero
code: @[to_additive (attr := simp)]
theorem fromLeftInv_one : S.fromLeftInv 1 = 1 
goal: S.fromLeftNeg 0 = 0

full_name: Submonoid.fromLeftInv_mul
code: @[to_additive (attr := simp)]
theorem fromLeftInv_mul (x : S.leftInv) : (S.fromLeftInv x : M) * x = 1 
goal: ↑(S.fromLeftInv x) * ↑x = 1

full_name: AddSubmonoid.fromLeftNeg_add
code: @[to_additive (attr := simp)]
theorem fromLeftInv_mul (x : S.leftInv) : (S.fromLeftInv x : M) * x = 1 
goal: ↑(S.fromLeftNeg x) + ↑x = 0

full_name: Submonoid.leftInv_le_isUnit
code: @[to_additive]
theorem leftInv_le_isUnit : S.leftInv ≤ IsUnit.submonoid M 
goal: S.leftInv ≤ IsUnit.submonoid M

full_name: AddSubmonoid.leftNeg_le_isAddUnit
code: @[to_additive]
theorem leftInv_le_isUnit : S.leftInv ≤ IsUnit.submonoid M 
goal: S.leftNeg ≤ IsAddUnit.addSubmonoid M

full_name: Submonoid.fromLeftInv_eq_iff
code: @[to_additive]
theorem fromLeftInv_eq_iff (a : S.leftInv) (b : M) :
    (S.fromLeftInv a : M) = b ↔ (a : M) * b = 1 
goal: ↑(S.fromLeftInv a) = b ↔ ↑a * b = 1

full_name: AddSubmonoid.fromLeftNeg_eq_iff
code: @[to_additive]
theorem fromLeftInv_eq_iff (a : S.leftInv) (b : M) :
    (S.fromLeftInv a : M) = b ↔ (a : M) * b = 1 
goal: ↑(S.fromLeftNeg a) = b ↔ ↑a + b = 0

full_name: AddSubmonoid.fromCommLeftNeg_apply
code: /-- The `MonoidHom` from `S.leftInv` to `S` sending an element to its right inverse in `S`. -/
@[to_additive (attr := simps)
    "The `AddMonoidHom` from `S.leftNeg` to `S` sending an element to its
    right additive inverse in `S`."]
noncomputable def fromCommLeftInv : S.leftInv →* S 
goal: ∀ (a : ↥S.leftNeg), S.fromCommLeftNeg a = S.fromLeftNeg a

full_name: AddSubmonoid.fromCommLeftNeg
code: /-- The `MonoidHom` from `S.leftInv` to `S` sending an element to its right inverse in `S`. -/
@[to_additive (attr := simps)
    "The `AddMonoidHom` from `S.leftNeg` to `S` sending an element to its
    right additive inverse in `S`."]
noncomputable def fromCommLeftInv : S.leftInv →* S 
goal: ↥S.leftNeg →+ ↥S

full_name: Submonoid.fromCommLeftInv
code: /-- The `MonoidHom` from `S.leftInv` to `S` sending an element to its right inverse in `S`. -/
@[to_additive (attr := simps)
    "The `AddMonoidHom` from `S.leftNeg` to `S` sending an element to its
    right additive inverse in `S`."]
noncomputable def fromCommLeftInv : S.leftInv →* S 
goal: ↥S.leftInv →* ↥S

full_name: Submonoid.fromCommLeftInv_apply
code: /-- The `MonoidHom` from `S.leftInv` to `S` sending an element to its right inverse in `S`. -/
@[to_additive (attr := simps)
    "The `AddMonoidHom` from `S.leftNeg` to `S` sending an element to its
    right additive inverse in `S`."]
noncomputable def fromCommLeftInv : S.leftInv →* S 
goal: ∀ (a : ↥S.leftInv), S.fromCommLeftInv a = S.fromLeftInv a

full_name: AddSubmonoid.leftNegEquiv
code: /-- The submonoid of pointwise inverse of `S` is `MulEquiv` to `S`. -/
@[to_additive (attr := simps apply) "The additive submonoid of pointwise additive inverse of `S` is
`AddEquiv` to `S`."]
noncomputable def leftInvEquiv : S.leftInv ≃* S 
goal: ↥S.leftNeg ≃+ ↥S

full_name: Submonoid.leftInvEquiv
code: /-- The submonoid of pointwise inverse of `S` is `MulEquiv` to `S`. -/
@[to_additive (attr := simps apply) "The additive submonoid of pointwise additive inverse of `S` is
`AddEquiv` to `S`."]
noncomputable def leftInvEquiv : S.leftInv ≃* S 
goal: ↥S.leftInv ≃* ↥S

full_name: Submonoid.leftInvEquiv_apply
code: /-- The submonoid of pointwise inverse of `S` is `MulEquiv` to `S`. -/
@[to_additive (attr := simps apply) "The additive submonoid of pointwise additive inverse of `S` is
`AddEquiv` to `S`."]
noncomputable def leftInvEquiv : S.leftInv ≃* S 
goal: ∀ (a : ↥S.leftInv), (S.leftInvEquiv hS) a = (↑S.fromCommLeftInv).toFun a

full_name: AddSubmonoid.leftNegEquiv_apply
code: /-- The submonoid of pointwise inverse of `S` is `MulEquiv` to `S`. -/
@[to_additive (attr := simps apply) "The additive submonoid of pointwise additive inverse of `S` is
`AddEquiv` to `S`."]
noncomputable def leftInvEquiv : S.leftInv ≃* S 
goal: ∀ (a : ↥S.leftNeg), (S.leftNegEquiv hS) a = (↑S.fromCommLeftNeg).toFun a

full_name: AddSubmonoid.fromLeftNeg_leftNegEquiv_symm
code: @[to_additive (attr := simp)]
theorem fromLeftInv_leftInvEquiv_symm (x : S) : S.fromLeftInv ((S.leftInvEquiv hS).symm x) = x 
goal: S.fromLeftNeg ((S.leftNegEquiv hS).symm x) = x

full_name: Submonoid.fromLeftInv_leftInvEquiv_symm
code: @[to_additive (attr := simp)]
theorem fromLeftInv_leftInvEquiv_symm (x : S) : S.fromLeftInv ((S.leftInvEquiv hS).symm x) = x 
goal: S.fromLeftInv ((S.leftInvEquiv hS).symm x) = x

full_name: Submonoid.leftInvEquiv_symm_fromLeftInv
code: @[to_additive (attr := simp)]
theorem leftInvEquiv_symm_fromLeftInv (x : S.leftInv) :
    (S.leftInvEquiv hS).symm (S.fromLeftInv x) = x 
goal: (S.leftInvEquiv hS).symm (S.fromLeftInv x) = x

full_name: AddSubmonoid.leftNegEquiv_symm_fromLeftNeg
code: @[to_additive (attr := simp)]
theorem leftInvEquiv_symm_fromLeftInv (x : S.leftInv) :
    (S.leftInvEquiv hS).symm (S.fromLeftInv x) = x 
goal: (S.leftNegEquiv hS).symm (S.fromLeftNeg x) = x

full_name: Submonoid.leftInvEquiv_mul
code: @[to_additive]
theorem leftInvEquiv_mul (x : S.leftInv) : (S.leftInvEquiv hS x : M) * x = 1 
goal: ↑((S.leftInvEquiv hS) x) * ↑x = 1

full_name: AddSubmonoid.leftNegEquiv_add
code: @[to_additive]
theorem leftInvEquiv_mul (x : S.leftInv) : (S.leftInvEquiv hS x : M) * x = 1 
goal: ↑((S.leftNegEquiv hS) x) + ↑x = 0

full_name: Submonoid.mul_leftInvEquiv
code: @[to_additive]
theorem mul_leftInvEquiv (x : S.leftInv) : (x : M) * S.leftInvEquiv hS x = 1 
goal: ↑x * ↑((S.leftInvEquiv hS) x) = 1

full_name: AddSubmonoid.add_leftNegEquiv
code: @[to_additive]
theorem mul_leftInvEquiv (x : S.leftInv) : (x : M) * S.leftInvEquiv hS x = 1 
goal: ↑x + ↑((S.leftNegEquiv hS) x) = 0

full_name: Submonoid.leftInvEquiv_symm_mul
code: @[to_additive (attr := simp)]
theorem leftInvEquiv_symm_mul (x : S) : ((S.leftInvEquiv hS).symm x : M) * x = 1 
goal: ↑((S.leftInvEquiv hS).symm x) * ↑x = 1

full_name: AddSubmonoid.leftNegEquiv_symm_add
code: @[to_additive (attr := simp)]
theorem leftInvEquiv_symm_mul (x : S) : ((S.leftInvEquiv hS).symm x : M) * x = 1 
goal: ↑((S.leftNegEquiv hS).symm x) + ↑x = 0

full_name: AddSubmonoid.add_leftNegEquiv_symm
code: @[to_additive (attr := simp)]
theorem mul_leftInvEquiv_symm (x : S) : (x : M) * (S.leftInvEquiv hS).symm x = 1 
goal: ↑x + ↑((S.leftNegEquiv hS).symm x) = 0

full_name: Submonoid.mul_leftInvEquiv_symm
code: @[to_additive (attr := simp)]
theorem mul_leftInvEquiv_symm (x : S) : (x : M) * (S.leftInvEquiv hS).symm x = 1 
goal: ↑x * ↑((S.leftInvEquiv hS).symm x) = 1

full_name: Submonoid.leftInv_eq_inv
code: @[to_additive]
theorem leftInv_eq_inv : S.leftInv = S⁻¹ 
goal: S.leftInv = S⁻¹

full_name: AddSubmonoid.leftNeg_eq_neg
code: @[to_additive]
theorem leftInv_eq_inv : S.leftInv = S⁻¹ 
goal: S.leftNeg = -S

full_name: AddSubmonoid.fromLeftNeg_eq_neg
code: @[to_additive (attr := simp)]
theorem fromLeftInv_eq_inv (x : S.leftInv) : (S.fromLeftInv x : M) = (x : M)⁻¹ 
goal: ↑(S.fromLeftNeg x) = -↑x

full_name: Submonoid.fromLeftInv_eq_inv
code: @[to_additive (attr := simp)]
theorem fromLeftInv_eq_inv (x : S.leftInv) : (S.fromLeftInv x : M) = (x : M)⁻¹ 
goal: ↑(S.fromLeftInv x) = (↑x)⁻¹

full_name: Submonoid.leftInvEquiv_symm_eq_inv
code: @[to_additive (attr := simp)]
theorem leftInvEquiv_symm_eq_inv (x : S) : ((S.leftInvEquiv hS).symm x : M) = (x : M)⁻¹ 
goal: ↑((S.leftInvEquiv hS).symm x) = (↑x)⁻¹

full_name: AddSubmonoid.leftNegEquiv_symm_eq_neg
code: @[to_additive (attr := simp)]
theorem leftInvEquiv_symm_eq_inv (x : S) : ((S.leftInvEquiv hS).symm x : M) = (x : M)⁻¹ 
goal: ↑((S.leftNegEquiv hS).symm x) = -↑x