mathlib documentation

algebra.group.units

Units (i.e., invertible elements) of a multiplicative monoid #

source
structure units (α : Type u) [monoid α] :
Type u
  • val : α
  • inv : α
  • val_inv : (self.val) * self.inv = 1
  • inv_val : (self.inv) * self.val = 1

Units of a monoid, bundled version. An element of a monoid is a unit if it has a two-sided inverse. This version bundles the inverse element so that it can be computed. For a predicate see is_unit.

source
structure add_units (α : Type u) [add_monoid α] :
Type u
  • val : α
  • neg : α
  • val_neg : self.val + self.neg = 0
  • neg_val : self.neg + self.val = 0

Units of an add_monoid, bundled version. An element of an add_monoid is a unit if it has a two-sided additive inverse. This version bundles the inverse element so that it can be computed. For a predicate see is_add_unit.

source
theorem unique_has_zero {α : Type u_1} [unique α] [has_zero α] :
default α = 0
source
theorem unique_has_one {α : Type u_1} [unique α] [has_one α] :
default α = 1
source
@[protected, instance]
def add_units.has_coe {α : Type u} [add_monoid α] :
has_coe (add_units α) α
Equations
source
@[protected, instance]
def units.has_coe {α : Type u} [monoid α] :
has_coe (units α) α
Equations
source
@[protected, instance]
def units.has_inv {α : Type u} [monoid α] :
has_inv (units α)
Equations
source
@[protected, instance]
def add_units.has_neg {α : Type u} [add_monoid α] :
has_neg (add_units α)
Equations
source
def units.simps.coe {α : Type u} [monoid α] (u : units α) :
α

See Note [custom simps projection]

Equations
source
def add_units.simps.coe {α : Type u} [add_monoid α] (u : add_units α) :
α

See Note [custom simps projection]

Equations
source
def units.simps.coe_inv {α : Type u} [monoid α] (u : units α) :
α

See Note [custom simps projection]

Equations
source
def add_units.simps.coe_neg {α : Type u} [add_monoid α] (u : add_units α) :
α

See Note [custom simps projection]

Equations
source
@[simp]
theorem units.coe_mk {α : Type u} [monoid α] (a b : α) (h₁ : a * b = 1) (h₂ : b * a = 1) :
↑{val := a, inv := b, val_inv := h₁, inv_val := h₂} = a
source
@[simp]
theorem add_units.coe_mk {α : Type u} [add_monoid α] (a b : α) (h₁ : a + b = 0) (h₂ : b + a = 0) :
↑{val := a, neg := b, val_neg := h₁, neg_val := h₂} = a
source
@[ext]
theorem units.ext {α : Type u} [monoid α] :
function.injective coe
source
theorem add_units.ext {α : Type u} [add_monoid α] :
function.injective coe
source
@[norm_cast]
theorem units.eq_iff {α : Type u} [monoid α] {a b : units α} :
↑a = ↑b ↔ a = b
source
@[norm_cast]
theorem add_units.eq_iff {α : Type u} [add_monoid α] {a b : add_units α} :
↑a = ↑b ↔ a = b
source
theorem add_units.ext_iff {α : Type u} [add_monoid α] {a b : add_units α} :
a = b ↔ ↑a = ↑b
source
theorem units.ext_iff {α : Type u} [monoid α] {a b : units α} :
a = b ↔ ↑a = ↑b
source
@[protected, instance]
def add_units.decidable_eq {α : Type u} [add_monoid α] [decidable_eq α] :
decidable_eq (add_units α)
Equations
source
@[protected, instance]
def units.decidable_eq {α : Type u} [monoid α] [decidable_eq α] :
decidable_eq (units α)
Equations
source
@[simp]
theorem units.mk_coe {α : Type u} [monoid α] (u : units α) (y : α) (h₁ : (↑u) * y = 1) (h₂ : y * ↑u = 1) :
{val := ↑u, inv := y, val_inv := h₁, inv_val := h₂} = u
source
@[simp]
theorem add_units.mk_coe {α : Type u} [add_monoid α] (u : add_units α) (y : α) (h₁ : ↑u + y = 0) (h₂ : y + ↑u = 0) :
{val := ↑u, neg := y, val_neg := h₁, neg_val := h₂} = u
source
@[simp]
theorem units.coe_copy {α : Type u} [monoid α] (u : units α) (val : α) (hv : val = ↑u) (inv : α) (hi : inv = ↑u⁻¹) :
↑(u.copy val hv inv hi) = val
source
@[simp]
theorem add_units.coe_copy {α : Type u} [add_monoid α] (u : add_units α) (val : α) (hv : val = ↑u) (inv : α) (hi : inv = ↑-u) :
↑(u.copy val hv inv hi) = val
source
@[simp]
theorem units.coe_inv_copy {α : Type u} [monoid α] (u : units α) (val : α) (hv : val = ↑u) (inv : α) (hi : inv = ↑u⁻¹) :
↑(u.copy val hv inv hi)⁻¹ = inv
source
@[simp]
theorem add_units.coe_neg_copy {α : Type u} [add_monoid α] (u : add_units α) (val : α) (hv : val = ↑u) (inv : α) (hi : inv = ↑-u) :
↑-u.copy val hv inv hi = inv
source
def units.copy {α : Type u} [monoid α] (u : units α) (val : α) (hv : val = ↑u) (inv : α) (hi : inv = ↑u⁻¹) :
units α

Copy a unit, adjusting definition equalities.

Equations
source
def add_units.copy {α : Type u} [add_monoid α] (u : add_units α) (val : α) (hv : val = ↑u) (inv : α) (hi : inv = ↑-u) :
add_units α

Copy an add_unit, adjusting definitional equalities.

Equations
source
theorem add_units.copy_eq {α : Type u} [add_monoid α] (u : add_units α) (val : α) (hv : val = ↑u) (inv : α) (hi : inv = ↑-u) :
u.copy val hv inv hi = u
source
theorem units.copy_eq {α : Type u} [monoid α] (u : units α) (val : α) (hv : val = ↑u) (inv : α) (hi : inv = ↑u⁻¹) :
u.copy val hv inv hi = u
source
@[protected, instance]
def units.group {α : Type u} [monoid α] :
group (units α)

Units of a monoid form a group.

Equations
source
@[protected, instance]
def add_units.add_group {α : Type u} [add_monoid α] :
add_group (add_units α)
Equations
source
@[simp, norm_cast]
theorem add_units.coe_add {α : Type u} [add_monoid α] (a b : add_units α) :
↑(a + b) = ↑a + ↑b
source
@[simp, norm_cast]
theorem units.coe_mul {α : Type u} [monoid α] (a b : units α) :
↑a * b = (↑a) * ↑b
source
@[simp, norm_cast]
theorem units.coe_one {α : Type u} [monoid α] :
↑1 = 1
source
@[simp, norm_cast]
theorem add_units.coe_zero {α : Type u} [add_monoid α] :
↑0 = 0
source
@[simp, norm_cast]
theorem units.coe_eq_one {α : Type u} [monoid α] {a : units α} :
↑a = 1 ↔ a = 1
source
@[simp, norm_cast]
theorem add_units.coe_eq_zero {α : Type u} [add_monoid α] {a : add_units α} :
↑a = 0 ↔ a = 0
source
@[simp]
theorem add_units.neg_mk {α : Type u} [add_monoid α] (x y : α) (h₁ : x + y = 0) (h₂ : y + x = 0) :
-{val := x, neg := y, val_neg := h₁, neg_val := h₂} = {val := y, neg := x, val_neg := h₂, neg_val := h₁}
source
@[simp]
theorem units.inv_mk {α : Type u} [monoid α] (x y : α) (h₁ : x * y = 1) (h₂ : y * x = 1) :
{val := x, inv := y, val_inv := h₁, inv_val := h₂}⁻¹ = {val := y, inv := x, val_inv := h₂, inv_val := h₁}
source
@[simp]
theorem units.val_eq_coe {α : Type u} [monoid α] (a : units α) :
a.val = ↑a
source
@[simp]
theorem add_units.val_eq_coe {α : Type u} [add_monoid α] (a : add_units α) :
a.val = ↑a
source
@[simp]
theorem units.inv_eq_coe_inv {α : Type u} [monoid α] (a : units α) :
a.inv = ↑a⁻¹
source
@[simp]
theorem add_units.neg_eq_coe_neg {α : Type u} [add_monoid α] (a : add_units α) :
a.neg = ↑-a
source
@[simp]
theorem units.inv_mul {α : Type u} [monoid α] (a : units α) :
(↑a⁻¹) * ↑a = 1
source
@[simp]
theorem add_units.neg_add {α : Type u} [add_monoid α] (a : add_units α) :
↑-a + ↑a = 0
source
@[simp]
theorem units.mul_inv {α : Type u} [monoid α] (a : units α) :
(↑a) * ↑a⁻¹ = 1
source
@[simp]
theorem add_units.add_neg {α : Type u} [add_monoid α] (a : add_units α) :
↑a + ↑-a = 0
source
theorem add_units.neg_add_of_eq {α : Type u} [add_monoid α] {u : add_units α} {a : α} (h : ↑u = a) :
↑-u + a = 0
source
theorem units.inv_mul_of_eq {α : Type u} [monoid α] {u : units α} {a : α} (h : ↑u = a) :
(↑u⁻¹) * a = 1
source
theorem add_units.add_neg_of_eq {α : Type u} [add_monoid α] {u : add_units α} {a : α} (h : ↑u = a) :
a + ↑-u = 0
source
theorem units.mul_inv_of_eq {α : Type u} [monoid α] {u : units α} {a : α} (h : ↑u = a) :
a * ↑u⁻¹ = 1
source
@[simp]
theorem add_units.add_neg_cancel_left {α : Type u} [add_monoid α] (a : add_units α) (b : α) :
↑a + (↑-a + b) = b
source
@[simp]
theorem units.mul_inv_cancel_left {α : Type u} [monoid α] (a : units α) (b : α) :
(↑a) * (↑a⁻¹) * b = b
source
@[simp]
theorem units.inv_mul_cancel_left {α : Type u} [monoid α] (a : units α) (b : α) :
(↑a⁻¹) * (↑a) * b = b
source
@[simp]
theorem add_units.neg_add_cancel_left {α : Type u} [add_monoid α] (a : add_units α) (b : α) :
↑-a + (↑a + b) = b
source
@[simp]
theorem add_units.add_neg_cancel_right {α : Type u} [add_monoid α] (a : α) (b : add_units α) :
a + ↑b + ↑-b = a
source
@[simp]
theorem units.mul_inv_cancel_right {α : Type u} [monoid α] (a : α) (b : units α) :
(a * ↑b) * ↑b⁻¹ = a
source
@[simp]
theorem add_units.neg_add_cancel_right {α : Type u} [add_monoid α] (a : α) (b : add_units α) :
a + ↑-b + ↑b = a
source
@[simp]
theorem units.inv_mul_cancel_right {α : Type u} [monoid α] (a : α) (b : units α) :
(a * ↑b⁻¹) * ↑b = a
source
@[protected, instance]
def units.inhabited {α : Type u} [monoid α] :
inhabited (units α)
Equations
source
@[protected, instance]
def add_units.inhabited {α : Type u} [add_monoid α] :
inhabited (add_units α)
Equations
source
@[protected, instance]
def add_units.add_comm_group {α : Type u_1} [add_comm_monoid α] :
add_comm_group (add_units α)
Equations
source
@[protected, instance]
def units.comm_group {α : Type u_1} [comm_monoid α] :
comm_group (units α)
Equations
source
@[protected, instance]
def units.has_repr {α : Type u} [monoid α] [has_repr α] :
has_repr (units α)
Equations
source
@[protected, instance]
def add_units.has_repr {α : Type u} [add_monoid α] [has_repr α] :
has_repr (add_units α)
Equations
source
@[simp]
theorem add_units.add_right_inj {α : Type u} [add_monoid α] (a : add_units α) {b c : α} :
↑a + b = ↑a + c ↔ b = c
source
@[simp]
theorem units.mul_right_inj {α : Type u} [monoid α] (a : units α) {b c : α} :
(↑a) * b = (↑a) * c ↔ b = c
source
@[simp]
theorem units.mul_left_inj {α : Type u} [monoid α] (a : units α) {b c : α} :
b * ↑a = c * ↑a ↔ b = c
source
@[simp]
theorem add_units.add_left_inj {α : Type u} [add_monoid α] (a : add_units α) {b c : α} :
b + ↑a = c + ↑a ↔ b = c
source
theorem add_units.eq_add_neg_iff_add_eq {α : Type u} [add_monoid α] {c : add_units α} {a b : α} :
a = b + ↑-c ↔ a + ↑c = b
source
theorem units.eq_mul_inv_iff_mul_eq {α : Type u} [monoid α] {c : units α} {a b : α} :
a = b * ↑c⁻¹ ↔ a * ↑c = b
source
theorem units.eq_inv_mul_iff_mul_eq {α : Type u} [monoid α] (b : units α) {a c : α} :
a = (↑b⁻¹) * c ↔ (↑b) * a = c
source
theorem add_units.eq_neg_add_iff_add_eq {α : Type u} [add_monoid α] (b : add_units α) {a c : α} :
a = ↑-b + c ↔ ↑b + a = c
source
theorem add_units.neg_add_eq_iff_eq_add {α : Type u} [add_monoid α] (a : add_units α) {b c : α} :
↑-a + b = c ↔ b = ↑a + c
source
theorem units.inv_mul_eq_iff_eq_mul {α : Type u} [monoid α] (a : units α) {b c : α} :
(↑a⁻¹) * b = c ↔ b = (↑a) * c
source
theorem units.mul_inv_eq_iff_eq_mul {α : Type u} [monoid α] (b : units α) {a c : α} :
a * ↑b⁻¹ = c ↔ a = c * ↑b
source
theorem add_units.add_neg_eq_iff_eq_add {α : Type u} [add_monoid α] (b : add_units α) {a c : α} :
a + ↑-b = c ↔ a = c + ↑b
source
theorem units.inv_eq_of_mul_eq_one {α : Type u} [monoid α] {u : units α} {a : α} (h : (↑u) * a = 1) :
↑u⁻¹ = a
source
theorem units.inv_unique {α : Type u} [monoid α] {u₁ u₂ : units α} (h : ↑u₁ = ↑u₂) :
↑u₁⁻¹ = ↑u₂⁻¹
source
def add_units.mk_of_add_eq_zero {α : Type u} [add_comm_monoid α] (a b : α) (hab : a + b = 0) :
add_units α

For a, b in an add_comm_monoid such that a + b = 0, makes an add_unit out of a.

Equations
source
def units.mk_of_mul_eq_one {α : Type u} [comm_monoid α] (a b : α) (hab : a * b = 1) :
units α

For a, b in a comm_monoid such that a * b = 1, makes a unit out of a.

Equations
source
@[simp]
theorem units.coe_mk_of_mul_eq_one {α : Type u} [comm_monoid α] {a b : α} (h : a * b = 1) :
↑(units.mk_of_mul_eq_one a b h) = a
source
@[simp]
theorem add_units.coe_mk_of_add_eq_zero {α : Type u} [add_comm_monoid α] {a b : α} (h : a + b = 0) :
↑(add_units.mk_of_add_eq_zero a b h) = a
source
def divp {α : Type u} [monoid α] (a : α) (u : units α) :
α

Partial division. It is defined when the second argument is invertible, and unlike the division operator in division_ring it is not totalized at zero.

Equations
source
@[simp]
theorem divp_self {α : Type u} [monoid α] (u : units α) :
↑u /ₚ u = 1
source
@[simp]
theorem divp_one {α : Type u} [monoid α] (a : α) :
a /ₚ 1 = a
source
theorem divp_assoc {α : Type u} [monoid α] (a b : α) (u : units α) :
a * b /ₚ u = a * (b /ₚ u)
source
@[simp]
theorem divp_inv {α : Type u} [monoid α] {a : α} (u : units α) :
a /ₚ u⁻¹ = a * ↑u
source
@[simp]
theorem divp_mul_cancel {α : Type u} [monoid α] (a : α) (u : units α) :
(a /ₚ u) * ↑u = a
source
@[simp]
theorem mul_divp_cancel {α : Type u} [monoid α] (a : α) (u : units α) :
a * ↑u /ₚ u = a
source
@[simp]
theorem divp_left_inj {α : Type u} [monoid α] (u : units α) {a b : α} :
a /ₚ u = b /ₚ u ↔ a = b
source
theorem divp_divp_eq_divp_mul {α : Type u} [monoid α] (x : α) (u₁ u₂ : units α) :
x /ₚ u₁ /ₚ u₂ = x /ₚ u₂ * u₁
source
theorem divp_eq_iff_mul_eq {α : Type u} [monoid α] {x : α} {u : units α} {y : α} :
x /ₚ u = y ↔ y * ↑u = x
source
theorem divp_eq_one_iff_eq {α : Type u} [monoid α] {a : α} {u : units α} :
a /ₚ u = 1 ↔ a = ↑u
source
@[simp]
theorem one_divp {α : Type u} [monoid α] (u : units α) :
1 /ₚ u = ↑u⁻¹
source
theorem divp_eq_divp_iff {α : Type u} [comm_monoid α] {x y : α} {ux uy : units α} :
x /ₚ ux = y /ₚ uy ↔ x * ↑uy = y * ↑ux
source
theorem divp_mul_divp {α : Type u} [comm_monoid α] (x y : α) (ux uy : units α) :
(x /ₚ ux) * (y /ₚ uy) = x * y /ₚ ux * uy

is_unit predicate #

In this file we define the is_unit predicate on a monoid, and prove a few basic properties. For the bundled version see units. See also prime, associated, and irreducible in algebra/associated.

source
def is_unit {M : Type u_1} [monoid M] (a : M) :
Prop

An element a : M of a monoid is a unit if it has a two-sided inverse. The actual definition says that a is equal to some u : units M, where units M is a bundled version of is_unit.

Equations
source
def is_add_unit {M : Type u_1} [add_monoid M] (a : M) :
Prop

An element a : M of an add_monoid is an add_unit if it has a two-sided additive inverse. The actual definition says that a is equal to some u : add_units M, where add_units M is a bundled version of is_add_unit.

Equations
source
theorem is_unit_of_subsingleton {M : Type u_1} [monoid M] [subsingleton M] (a : M) :
is_unit a
source
@[protected, instance]
def units.unique {M : Type u_1} [monoid M] [subsingleton M] :
unique (units M)
Equations
source
@[protected, simp]
theorem units.is_unit {M : Type u_1} [monoid M] (u : units M) :
is_unit ↑u
source
@[protected, simp]
theorem add_units.is_add_unit_add_unit {M : Type u_1} [add_monoid M] (u : add_units M) :
is_add_unit ↑u
source
@[simp]
theorem is_unit_one {M : Type u_1} [monoid M] :
is_unit 1
source
@[simp]
theorem is_add_unit_zero {M : Type u_1} [add_monoid M] :
is_add_unit 0
source
theorem is_unit_of_mul_eq_one {M : Type u_1} [comm_monoid M] (a b : M) (h : a * b = 1) :
is_unit a
source
theorem is_add_unit_of_add_eq_zero {M : Type u_1} [add_comm_monoid M] (a b : M) (h : a + b = 0) :
is_add_unit a
source
theorem is_unit.exists_right_inv {M : Type u_1} [monoid M] {a : M} (h : is_unit a) :
∃ (b : M), a * b = 1
source
theorem is_add_unit.exists_neg {M : Type u_1} [add_monoid M] {a : M} (h : is_add_unit a) :
∃ (b : M), a + b = 0
source
theorem is_unit.exists_left_inv {M : Type u_1} [monoid M] {a : M} (h : is_unit a) :
∃ (b : M), b * a = 1
source
theorem is_add_unit.exists_neg' {M : Type u_1} [add_monoid M] {a : M} (h : is_add_unit a) :
∃ (b : M), b + a = 0
source
theorem is_unit_iff_exists_inv {M : Type u_1} [comm_monoid M] {a : M} :
is_unit a ↔ ∃ (b : M), a * b = 1
source
theorem is_add_unit_iff_exists_neg {M : Type u_1} [add_comm_monoid M] {a : M} :
is_add_unit a ↔ ∃ (b : M), a + b = 0
source
theorem is_add_unit_iff_exists_neg' {M : Type u_1} [add_comm_monoid M] {a : M} :
is_add_unit a ↔ ∃ (b : M), b + a = 0
source
theorem is_unit_iff_exists_inv' {M : Type u_1} [comm_monoid M] {a : M} :
is_unit a ↔ ∃ (b : M), b * a = 1
source
theorem is_add_unit.add {M : Type u_1} [add_monoid M] {x y : M} :
is_add_unit x → is_add_unit y → is_add_unit (x + y)
source
theorem is_unit.mul {M : Type u_1} [monoid M] {x y : M} :
is_unit x → is_unit y → is_unit (x * y)
source
@[simp]
theorem add_units.is_add_unit_add_add_units {M : Type u_1} [add_monoid M] (a : M) (u : add_units M) :
is_add_unit (a + ↑u) ↔ is_add_unit a

Addition of a u : add_units M on the right doesn't affect is_add_unit.

source
@[simp]
theorem units.is_unit_mul_units {M : Type u_1} [monoid M] (a : M) (u : units M) :
is_unit (a * ↑u) ↔ is_unit a

Multiplication by a u : units M on the right doesn't affect is_unit.

source
@[simp]
theorem add_units.is_add_unit_add_units_add {M : Type u_1} [add_monoid M] (u : add_units M) (a : M) :
is_add_unit (↑u + a) ↔ is_add_unit a

Addition of a u : add_units M on the left doesn't affect is_add_unit.

source
@[simp]
theorem units.is_unit_units_mul {M : Type u_1} [monoid M] (u : units M) (a : M) :
is_unit ((↑u) * a) ↔ is_unit a

Multiplication by a u : units M on the left doesn't affect is_unit.

source
theorem is_unit_of_mul_is_unit_left {M : Type u_1} [comm_monoid M] {x y : M} (hu : is_unit (x * y)) :
is_unit x
source
theorem is_add_unit_of_add_is_add_unit_left {M : Type u_1} [add_comm_monoid M] {x y : M} (hu : is_add_unit (x + y)) :
is_add_unit x
source
theorem is_unit_of_add_is_unit_right {M : Type u_1} [add_comm_monoid M] {x y : M} (hu : is_add_unit (x + y)) :
is_add_unit y
source
theorem is_unit_of_mul_is_unit_right {M : Type u_1} [comm_monoid M] {x y : M} (hu : is_unit (x * y)) :
is_unit y
source
@[simp]
theorem is_unit.mul_iff {M : Type u_1} [comm_monoid M] {x y : M} :
is_unit (x * y) ↔ is_unit x ∧ is_unit y
source
theorem is_add_unit.add_right_inj {M : Type u_1} [add_monoid M] {a b c : M} (ha : is_add_unit a) :
a + b = a + c ↔ b = c
source
theorem is_unit.mul_right_inj {M : Type u_1} [monoid M] {a b c : M} (ha : is_unit a) :
a * b = a * c ↔ b = c
source
theorem is_unit.mul_left_inj {M : Type u_1} [monoid M] {a b c : M} (ha : is_unit a) :
b * a = c * a ↔ b = c
source
theorem is_add_unit.add_left_inj {M : Type u_1} [add_monoid M] {a b c : M} (ha : is_add_unit a) :
b + a = c + a ↔ b = c
source
noncomputable def is_add_unit.unit {M : Type u_1} [add_monoid M] {a : M} (h : is_add_unit a) :
add_units M

The element of the additive group of additive units, corresponding to an element of an additive monoid which is an additive unit.

Equations
source
noncomputable def is_unit.unit {M : Type u_1} [monoid M] {a : M} (h : is_unit a) :
units M

The element of the group of units, corresponding to an element of a monoid which is a unit.

Equations
source
theorem is_unit.unit_spec {M : Type u_1} [monoid M] {a : M} (h : is_unit a) :
↑(h.unit) = a
source
theorem is_add_unit.unit_spec {M : Type u_1} [add_monoid M] {a : M} (h : is_add_unit a) :
↑(h.unit) = a
source
theorem is_add_unit.coe_neg_add {M : Type u_1} [add_monoid M] {a : M} (h : is_add_unit a) :
↑-h.unit + a = 0
source
theorem is_unit.coe_inv_mul {M : Type u_1} [monoid M] {a : M} (h : is_unit a) :
(↑(h.unit)⁻¹) * a = 1
source
theorem is_add_unit.add_coe_neg {M : Type u_1} [add_monoid M] {a : M} (h : is_add_unit a) :
a + ↑-h.unit = 0
source
theorem is_unit.mul_coe_inv {M : Type u_1} [monoid M] {a : M} (h : is_unit a) :
a * ↑(h.unit)⁻¹ = 1
source
noncomputable def group_of_is_unit {M : Type u_1} [hM : monoid M] (h : ∀ (a : M), is_unit a) :
group M

Constructs a group structure on a monoid consisting only of units.

Equations
source
noncomputable def comm_group_of_is_unit {M : Type u_1} [hM : comm_monoid M] (h : ∀ (a : M), is_unit a) :
comm_group M

Constructs a comm_group structure on a comm_monoid consisting only of units.

Equations