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

full_name: Submonoid.units
code: /-- The units of `S`, packaged as a subgroup of `Mˣ`.  -/
@[to_additive " The additive units of `S`, packaged as an additive subgroup of `AddUnits M`. "]
def Submonoid.units (S : Submonoid M) : Subgroup Mˣ 
goal: Subgroup Mˣ

full_name: AddSubmonoid.addUnits
code: /-- The units of `S`, packaged as a subgroup of `Mˣ`.  -/
@[to_additive " The additive units of `S`, packaged as an additive subgroup of `AddUnits M`. "]
def Submonoid.units (S : Submonoid M) : Subgroup Mˣ 
goal: AddSubgroup (AddUnits M)

full_name: Subgroup.ofUnits
code: /-- A subgroup of units represented as a submonoid of `M`.  -/
@[to_additive " A additive subgroup of additive units represented as a additive submonoid of `M`. "]
def Subgroup.ofUnits (S : Subgroup Mˣ) : Submonoid M 
goal: Submonoid M

full_name: AddSubgroup.ofAddUnits
code: /-- A subgroup of units represented as a submonoid of `M`.  -/
@[to_additive " A additive subgroup of additive units represented as a additive submonoid of `M`. "]
def Subgroup.ofUnits (S : Subgroup Mˣ) : Submonoid M 
goal: AddSubmonoid M

full_name: AddSubmonoid.addUnits_mono
code: @[to_additive]
lemma Submonoid.units_mono : Monotone (Submonoid.units (M := M)) 
goal: Monotone AddSubmonoid.addUnits

full_name: Submonoid.units_mono
code: @[to_additive]
lemma Submonoid.units_mono : Monotone (Submonoid.units (M := M)) 
goal: Monotone Submonoid.units

full_name: Submonoid.ofUnits_units_le
code: @[to_additive (attr := simp)]
lemma Submonoid.ofUnits_units_le (S : Submonoid M) : S.units.ofUnits ≤ S 
goal: S.units.ofUnits ≤ S

full_name: AddSubmonoid.ofAddUnits_addUnits_le
code: @[to_additive (attr := simp)]
lemma Submonoid.ofUnits_units_le (S : Submonoid M) : S.units.ofUnits ≤ S 
goal: S.addUnits.ofAddUnits ≤ S

full_name: Subgroup.ofUnits_mono
code: @[to_additive]
lemma Subgroup.ofUnits_mono : Monotone (Subgroup.ofUnits (M := M)) 
goal: Monotone Subgroup.ofUnits

full_name: AddSubgroup.ofAddUnits_mono
code: @[to_additive]
lemma Subgroup.ofUnits_mono : Monotone (Subgroup.ofUnits (M := M)) 
goal: Monotone AddSubgroup.ofAddUnits

full_name: Subgroup.units_ofUnits_eq
code: @[to_additive (attr := simp)]
lemma Subgroup.units_ofUnits_eq (S : Subgroup Mˣ) : S.ofUnits.units = S 
goal: S.ofUnits.units = S

full_name: AddSubgroup.addUnits_ofAddUnits_eq
code: @[to_additive (attr := simp)]
lemma Subgroup.units_ofUnits_eq (S : Subgroup Mˣ) : S.ofUnits.units = S 
goal: S.ofAddUnits.addUnits = S

full_name: ofUnits_units_gci
code: /-- A Galois coinsertion exists between the coercion from a subgroup of units to a submonoid and
the reduction from a submonoid to its unit group. -/
@[to_additive " A Galois coinsertion exists between the coercion from a additive subgroup of
additive units to a additive submonoid and the reduction from a additive submonoid to its unit
group. " ]
def ofUnits_units_gci : GaloisCoinsertion (Subgroup.ofUnits (M := M)) (Submonoid.units) 
goal: GaloisCoinsertion Subgroup.ofUnits Submonoid.units

full_name: ofAddUnits_addUnits_gci
code: /-- A Galois coinsertion exists between the coercion from a subgroup of units to a submonoid and
the reduction from a submonoid to its unit group. -/
@[to_additive " A Galois coinsertion exists between the coercion from a additive subgroup of
additive units to a additive submonoid and the reduction from a additive submonoid to its unit
group. " ]
def ofUnits_units_gci : GaloisCoinsertion (Subgroup.ofUnits (M := M)) (Submonoid.units) 
goal: GaloisCoinsertion AddSubgroup.ofAddUnits AddSubmonoid.addUnits

full_name: ofUnits_units_gc
code: @[to_additive]
lemma ofUnits_units_gc : GaloisConnection (Subgroup.ofUnits (M := M)) (Submonoid.units) 
goal: GaloisConnection Subgroup.ofUnits Submonoid.units

full_name: ofAddUnits_addUnits_gc
code: @[to_additive]
lemma ofUnits_units_gc : GaloisConnection (Subgroup.ofUnits (M := M)) (Submonoid.units) 
goal: GaloisConnection AddSubgroup.ofAddUnits AddSubmonoid.addUnits

full_name: ofUnits_le_iff_le_units
code: @[to_additive]
lemma ofUnits_le_iff_le_units (S : Submonoid M) (H : Subgroup Mˣ) :
    H.ofUnits ≤ S ↔ H ≤ S.units 
goal: H.ofUnits ≤ S ↔ H ≤ S.units

full_name: ofAddUnits_le_iff_le_addUnits
code: @[to_additive]
lemma ofUnits_le_iff_le_units (S : Submonoid M) (H : Subgroup Mˣ) :
    H.ofUnits ≤ S ↔ H ≤ S.units 
goal: H.ofAddUnits ≤ S ↔ H ≤ S.addUnits

full_name: Submonoid.mem_units_iff
code: @[to_additive]
lemma mem_units_iff (S : Submonoid M) (x : Mˣ) : x ∈ S.units ↔
    ((x : M) ∈ S ∧ ((x⁻¹ : Mˣ) : M) ∈ S) 
goal: x ∈ S.units ↔ ↑x ∈ S ∧ ↑x⁻¹ ∈ S

full_name: AddSubmonoid.mem_addUnits_iff
code: @[to_additive]
lemma mem_units_iff (S : Submonoid M) (x : Mˣ) : x ∈ S.units ↔
    ((x : M) ∈ S ∧ ((x⁻¹ : Mˣ) : M) ∈ S) 
goal: x ∈ S.addUnits ↔ ↑x ∈ S ∧ ↑(-x) ∈ S

full_name: Submonoid.mem_units_of_val_mem_inv_val_mem
code: @[to_additive]
lemma mem_units_of_val_mem_inv_val_mem (S : Submonoid M) {x : Mˣ} (h₁ : (x : M) ∈ S)
    (h₂ : ((x⁻¹ : Mˣ) : M) ∈ S) : x ∈ S.units 
goal: x ∈ S.units

full_name: AddSubmonoid.mem_addUnits_of_val_mem_neg_val_mem
code: @[to_additive]
lemma mem_units_of_val_mem_inv_val_mem (S : Submonoid M) {x : Mˣ} (h₁ : (x : M) ∈ S)
    (h₂ : ((x⁻¹ : Mˣ) : M) ∈ S) : x ∈ S.units 
goal: x ∈ S.addUnits

full_name: AddSubmonoid.val_mem_of_mem_addUnits
code: @[to_additive]
lemma val_mem_of_mem_units (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units) : (x : M) ∈ S 
goal: ↑x ∈ S

full_name: Submonoid.val_mem_of_mem_units
code: @[to_additive]
lemma val_mem_of_mem_units (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units) : (x : M) ∈ S 
goal: ↑x ∈ S

full_name: AddSubmonoid.neg_val_mem_of_mem_addUnits
code: @[to_additive]
lemma inv_val_mem_of_mem_units (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units) :
    ((x⁻¹ : Mˣ) : M) ∈ S 
goal: ↑(-x) ∈ S

full_name: Submonoid.inv_val_mem_of_mem_units
code: @[to_additive]
lemma inv_val_mem_of_mem_units (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units) :
    ((x⁻¹ : Mˣ) : M) ∈ S 
goal: ↑x⁻¹ ∈ S

full_name: Submonoid.coe_inv_val_mul_coe_val
code: @[to_additive]
lemma coe_inv_val_mul_coe_val (S : Submonoid M) {x : Sˣ} :
    ((x⁻¹ : Sˣ) : M) * ((x : Sˣ) : M) = 1 
goal: ↑↑x⁻¹ * ↑↑x = 1

full_name: AddSubmonoid.coe_neg_val_add_coe_val
code: @[to_additive]
lemma coe_inv_val_mul_coe_val (S : Submonoid M) {x : Sˣ} :
    ((x⁻¹ : Sˣ) : M) * ((x : Sˣ) : M) = 1 
goal: ↑↑(-x) + ↑↑x = 0

full_name: Submonoid.coe_val_mul_coe_inv_val
code: @[to_additive]
lemma coe_val_mul_coe_inv_val (S : Submonoid M) {x : Sˣ} :
    ((x : Sˣ) : M) * ((x⁻¹ : Sˣ) : M) = 1 
goal: ↑↑x * ↑↑x⁻¹ = 1

full_name: AddSubmonoid.coe_val_add_coe_neg_val
code: @[to_additive]
lemma coe_val_mul_coe_inv_val (S : Submonoid M) {x : Sˣ} :
    ((x : Sˣ) : M) * ((x⁻¹ : Sˣ) : M) = 1 
goal: ↑↑x + ↑↑(-x) = 0

full_name: Submonoid.mk_inv_mul_mk_eq_one
code: @[to_additive]
lemma mk_inv_mul_mk_eq_one (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units) :
    (⟨_, h.2⟩ : S) * ⟨_, h.1⟩ = 1 
goal: ⟨(Units.coeHom M) x⁻¹, ⋯⟩ * ⟨(Units.coeHom M) x, ⋯⟩ = 1

full_name: AddSubmonoid.mk_neg_add_mk_eq_zero
code: @[to_additive]
lemma mk_inv_mul_mk_eq_one (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units) :
    (⟨_, h.2⟩ : S) * ⟨_, h.1⟩ = 1 
goal: ⟨(AddUnits.coeHom M) (-x), ⋯⟩ + ⟨(AddUnits.coeHom M) x, ⋯⟩ = 0

full_name: Submonoid.mk_mul_mk_inv_eq_one
code: @[to_additive]
lemma mk_mul_mk_inv_eq_one (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units) :
    (⟨_, h.1⟩ : S) * ⟨_, h.2⟩ = 1 
goal: ⟨(Units.coeHom M) x, ⋯⟩ * ⟨(Units.coeHom M) x⁻¹, ⋯⟩ = 1

full_name: AddSubmonoid.mk_add_mk_neg_eq_zero
code: @[to_additive]
lemma mk_mul_mk_inv_eq_one (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units) :
    (⟨_, h.1⟩ : S) * ⟨_, h.2⟩ = 1 
goal: ⟨(AddUnits.coeHom M) x, ⋯⟩ + ⟨(AddUnits.coeHom M) (-x), ⋯⟩ = 0

full_name: AddSubmonoid.add_mem_addUnits
code: @[to_additive]
lemma mul_mem_units (S : Submonoid M) {x y : Mˣ} (h₁ : x ∈ S.units) (h₂ : y ∈ S.units) :
    x * y ∈ S.units 
goal: x + y ∈ S.addUnits

full_name: Submonoid.mul_mem_units
code: @[to_additive]
lemma mul_mem_units (S : Submonoid M) {x y : Mˣ} (h₁ : x ∈ S.units) (h₂ : y ∈ S.units) :
    x * y ∈ S.units 
goal: x * y ∈ S.units

full_name: Submonoid.inv_mem_units
code: @[to_additive]
lemma inv_mem_units (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units) : x⁻¹ ∈ S.units 
goal: x⁻¹ ∈ S.units

full_name: AddSubmonoid.neg_mem_addUnits
code: @[to_additive]
lemma inv_mem_units (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units) : x⁻¹ ∈ S.units 
goal: -x ∈ S.addUnits

full_name: Submonoid.inv_mem_units_iff
code: @[to_additive]
lemma inv_mem_units_iff (S : Submonoid M) {x : Mˣ} : x⁻¹ ∈ S.units ↔ x ∈ S.units 
goal: x⁻¹ ∈ S.units ↔ x ∈ S.units

full_name: AddSubmonoid.neg_mem_addUnits_iff
code: @[to_additive]
lemma inv_mem_units_iff (S : Submonoid M) {x : Mˣ} : x⁻¹ ∈ S.units ↔ x ∈ S.units 
goal: -x ∈ S.addUnits ↔ x ∈ S.addUnits

full_name: Submonoid.unitsEquivUnitsType
code: /-- The equivalence between the subgroup of units of `S` and the type of units of `S`. -/
@[to_additive " The equivalence between the additive subgroup of additive units of
`S` and the type of additive units of `S`. "]
def unitsEquivUnitsType (S : Submonoid M) : S.units ≃* Sˣ 
goal: ↥S.units ≃* (↥S)ˣ

full_name: AddSubmonoid.addUnitsEquivAddUnitsType
code: /-- The equivalence between the subgroup of units of `S` and the type of units of `S`. -/
@[to_additive " The equivalence between the additive subgroup of additive units of
`S` and the type of additive units of `S`. "]
def unitsEquivUnitsType (S : Submonoid M) : S.units ≃* Sˣ 
goal: ↥S.addUnits ≃+ AddUnits ↥S

full_name: Submonoid.units_top
code: @[to_additive (attr := simp)]
lemma units_top : (⊤ : Submonoid M).units = ⊤ 
goal: ⊤.units = ⊤

full_name: AddSubmonoid.addUnits_top
code: @[to_additive (attr := simp)]
lemma units_top : (⊤ : Submonoid M).units = ⊤ 
goal: ⊤.addUnits = ⊤

full_name: AddSubmonoid.addUnits_inf
code: @[to_additive]
lemma units_inf (S T : Submonoid M) : (S ⊓ T).units = S.units ⊓ T.units 
goal: (S ⊓ T).addUnits = S.addUnits ⊓ T.addUnits

full_name: Submonoid.units_inf
code: @[to_additive]
lemma units_inf (S T : Submonoid M) : (S ⊓ T).units = S.units ⊓ T.units 
goal: (S ⊓ T).units = S.units ⊓ T.units

full_name: AddSubmonoid.addUnits_sInf
code: @[to_additive]
lemma units_sInf {s : Set (Submonoid M)} : (sInf s).units = ⨅ S ∈ s, S.units 
goal: (sInf s).addUnits = ⨅ S ∈ s, S.addUnits

full_name: Submonoid.units_sInf
code: @[to_additive]
lemma units_sInf {s : Set (Submonoid M)} : (sInf s).units = ⨅ S ∈ s, S.units 
goal: (sInf s).units = ⨅ S ∈ s, S.units

full_name: AddSubmonoid.addUnits_iInf
code: @[to_additive]
lemma units_iInf {ι : Sort*} (f : ι → Submonoid M) : (iInf f).units = ⨅ (i : ι), (f i).units 
goal: (iInf f).addUnits = ⨅ i, (f i).addUnits

full_name: Submonoid.units_iInf
code: @[to_additive]
lemma units_iInf {ι : Sort*} (f : ι → Submonoid M) : (iInf f).units = ⨅ (i : ι), (f i).units 
goal: (iInf f).units = ⨅ i, (f i).units

full_name: AddSubmonoid.addUnits_iInf₂
code: @[to_additive]
lemma units_iInf₂ {ι : Sort*} {κ : ι → Sort*} (f : (i : ι) → κ i → Submonoid M) :
    (⨅ (i : ι), ⨅ (j : κ i), f i j).units = ⨅ (i : ι), ⨅ (j : κ i), (f i j).units 
goal: (⨅ i, ⨅ j, f i j).addUnits = ⨅ i, ⨅ j, (f i j).addUnits

full_name: Submonoid.units_iInf₂
code: @[to_additive]
lemma units_iInf₂ {ι : Sort*} {κ : ι → Sort*} (f : (i : ι) → κ i → Submonoid M) :
    (⨅ (i : ι), ⨅ (j : κ i), f i j).units = ⨅ (i : ι), ⨅ (j : κ i), (f i j).units 
goal: (⨅ i, ⨅ j, f i j).units = ⨅ i, ⨅ j, (f i j).units

full_name: AddSubmonoid.addUnits_bot
code: @[to_additive (attr := simp)]
lemma units_bot : (⊥ : Submonoid M).units = ⊥ 
goal: ⊥.addUnits = ⊥

full_name: Submonoid.units_bot
code: @[to_additive (attr := simp)]
lemma units_bot : (⊥ : Submonoid M).units = ⊥ 
goal: ⊥.units = ⊥

full_name: AddSubmonoid.addUnits_surjective
code: @[to_additive]
lemma units_surjective : Function.Surjective (units (M := M)) 
goal: Function.Surjective AddSubmonoid.addUnits

full_name: Submonoid.units_surjective
code: @[to_additive]
lemma units_surjective : Function.Surjective (units (M := M)) 
goal: Function.Surjective Submonoid.units

full_name: AddSubmonoid.addUnits_left_inverse
code: @[to_additive]
lemma units_left_inverse :
    Function.LeftInverse (units (M := M)) (Subgroup.ofUnits (M := M)) 
goal: Function.LeftInverse AddSubmonoid.addUnits AddSubgroup.ofAddUnits

full_name: Submonoid.units_left_inverse
code: @[to_additive]
lemma units_left_inverse :
    Function.LeftInverse (units (M := M)) (Subgroup.ofUnits (M := M)) 
goal: Function.LeftInverse Submonoid.units Subgroup.ofUnits

full_name: Submonoid.unitsEquivIsUnitSubmonoid
code: /-- The equivalence between the subgroup of units of `S` and the submonoid of unit
elements of `S`. -/
@[to_additive " The equivalence between the additive subgroup of additive units of
`S` and the additive submonoid of additive unit elements of `S`.  "]
noncomputable def unitsEquivIsUnitSubmonoid (S : Submonoid M) : S.units ≃* IsUnit.submonoid S 
goal: ↥S.units ≃* ↥(IsUnit.submonoid ↥S)

full_name: AddSubmonoid.addUnitsEquivIsAddUnitAddSubmonoid
code: /-- The equivalence between the subgroup of units of `S` and the submonoid of unit
elements of `S`. -/
@[to_additive " The equivalence between the additive subgroup of additive units of
`S` and the additive submonoid of additive unit elements of `S`.  "]
noncomputable def unitsEquivIsUnitSubmonoid (S : Submonoid M) : S.units ≃* IsUnit.submonoid S 
goal: ↥S.addUnits ≃+ ↥(IsAddUnit.addSubmonoid ↥S)

full_name: Subgroup.mem_ofUnits_iff
code: @[to_additive]
lemma mem_ofUnits_iff (S : Subgroup Mˣ) (x : M) : x ∈ S.ofUnits ↔ ∃ y ∈ S, y = x 
goal: x ∈ S.ofUnits ↔ ∃ y ∈ S, ↑y = x

full_name: AddSubgroup.mem_ofAddUnits_iff
code: @[to_additive]
lemma mem_ofUnits_iff (S : Subgroup Mˣ) (x : M) : x ∈ S.ofUnits ↔ ∃ y ∈ S, y = x 
goal: x ∈ S.ofAddUnits ↔ ∃ y ∈ S, ↑y = x

full_name: Subgroup.mem_ofUnits
code: @[to_additive]
lemma mem_ofUnits (S : Subgroup Mˣ) {x : M} {y : Mˣ} (h₁ : y ∈ S) (h₂ : y = x) : x ∈ S.ofUnits 
goal: x ∈ S.ofUnits

full_name: AddSubgroup.mem_ofAddUnits
code: @[to_additive]
lemma mem_ofUnits (S : Subgroup Mˣ) {x : M} {y : Mˣ} (h₁ : y ∈ S) (h₂ : y = x) : x ∈ S.ofUnits 
goal: x ∈ S.ofAddUnits

full_name: AddSubgroup.exists_mem_ofAddUnits_val_eq
code: @[to_additive]
lemma exists_mem_ofUnits_val_eq (S : Subgroup Mˣ) {x : M} (h : x ∈ S.ofUnits) :
    ∃ y ∈ S, y = x 
goal: ∃ y ∈ S, ↑y = x

full_name: Subgroup.exists_mem_ofUnits_val_eq
code: @[to_additive]
lemma exists_mem_ofUnits_val_eq (S : Subgroup Mˣ) {x : M} (h : x ∈ S.ofUnits) :
    ∃ y ∈ S, y = x 
goal: ∃ y ∈ S, ↑y = x

full_name: AddSubgroup.mem_of_mem_val_ofAddUnits
code: @[to_additive]
lemma mem_of_mem_val_ofUnits (S : Subgroup Mˣ) {y : Mˣ} (hy : (y : M) ∈ S.ofUnits) : y ∈ S 
goal: y ∈ S

full_name: Subgroup.mem_of_mem_val_ofUnits
code: @[to_additive]
lemma mem_of_mem_val_ofUnits (S : Subgroup Mˣ) {y : Mˣ} (hy : (y : M) ∈ S.ofUnits) : y ∈ S 
goal: y ∈ S

full_name: AddSubgroup.isAddUnit_of_mem_ofAddUnits
code: @[to_additive]
lemma isUnit_of_mem_ofUnits (S : Subgroup Mˣ) {x : M} (hx : x ∈ S.ofUnits) : IsUnit x 
goal: IsAddUnit x

full_name: Subgroup.isUnit_of_mem_ofUnits
code: @[to_additive]
lemma isUnit_of_mem_ofUnits (S : Subgroup Mˣ) {x : M} (hx : x ∈ S.ofUnits) : IsUnit x 
goal: IsUnit x

full_name: Subgroup.unit_of_mem_ofUnits
code: /-- Given some `x : M` which is a member of the submonoid of unit elements corresponding to a
  subgroup of units, produce a unit of `M` whose coercion is equal to `x`. `-/
@[to_additive " Given some `x : M` which is a member of the additive submonoid of additive unit
elements corresponding to a subgroup of units, produce a unit of `M` whose coercion is equal to
`x`. "]
noncomputable def unit_of_mem_ofUnits (S : Subgroup Mˣ) {x : M} (h : x ∈ S.ofUnits) : Mˣ 
goal: Mˣ

full_name: AddSubgroup.addUnit_of_mem_ofAddUnits
code: /-- Given some `x : M` which is a member of the submonoid of unit elements corresponding to a
  subgroup of units, produce a unit of `M` whose coercion is equal to `x`. `-/
@[to_additive " Given some `x : M` which is a member of the additive submonoid of additive unit
elements corresponding to a subgroup of units, produce a unit of `M` whose coercion is equal to
`x`. "]
noncomputable def unit_of_mem_ofUnits (S : Subgroup Mˣ) {x : M} (h : x ∈ S.ofUnits) : Mˣ 
goal: AddUnits M

full_name: AddSubgroup.addUnit_of_mem_ofAddUnits_spec_eq_of_val_mem
code: @[to_additive]
lemma unit_of_mem_ofUnits_spec_eq_of_val_mem (S : Subgroup Mˣ) {x : Mˣ} (h : (x : M) ∈ S.ofUnits) :
    S.unit_of_mem_ofUnits h = x 
goal: S.addUnit_of_mem_ofAddUnits h = x

full_name: Subgroup.unit_of_mem_ofUnits_spec_eq_of_val_mem
code: @[to_additive]
lemma unit_of_mem_ofUnits_spec_eq_of_val_mem (S : Subgroup Mˣ) {x : Mˣ} (h : (x : M) ∈ S.ofUnits) :
    S.unit_of_mem_ofUnits h = x 
goal: S.unit_of_mem_ofUnits h = x

full_name: AddSubgroup.addUnit_of_mem_ofAddUnits_spec_val_eq_of_mem
code: @[to_additive]
lemma unit_of_mem_ofUnits_spec_val_eq_of_mem (S : Subgroup Mˣ) {x : M} (h : x ∈ S.ofUnits) :
    S.unit_of_mem_ofUnits h = x 
goal: ↑(S.addUnit_of_mem_ofAddUnits h) = x

full_name: Subgroup.unit_of_mem_ofUnits_spec_val_eq_of_mem
code: @[to_additive]
lemma unit_of_mem_ofUnits_spec_val_eq_of_mem (S : Subgroup Mˣ) {x : M} (h : x ∈ S.ofUnits) :
    S.unit_of_mem_ofUnits h = x 
goal: ↑(S.unit_of_mem_ofUnits h) = x

full_name: Subgroup.unit_of_mem_ofUnits_spec_mem
code: @[to_additive]
lemma unit_of_mem_ofUnits_spec_mem (S : Subgroup Mˣ) {x : M} {h : x ∈ S.ofUnits} :
    S.unit_of_mem_ofUnits h ∈ S 
goal: S.unit_of_mem_ofUnits h ∈ S

full_name: AddSubgroup.addUnit_of_mem_ofAddUnits_spec_mem
code: @[to_additive]
lemma unit_of_mem_ofUnits_spec_mem (S : Subgroup Mˣ) {x : M} {h : x ∈ S.ofUnits} :
    S.unit_of_mem_ofUnits h ∈ S 
goal: S.addUnit_of_mem_ofAddUnits h ∈ S

full_name: AddSubgroup.addUnit_eq_addUnit_of_mem_ofAddUnits
code: @[to_additive]
lemma unit_eq_unit_of_mem_ofUnits (S : Subgroup Mˣ) {x : M} (h₁ : IsUnit x)
    (h₂ : x ∈ S.ofUnits) : h₁.unit = S.unit_of_mem_ofUnits h₂ 
goal: h₁.addUnit = S.addUnit_of_mem_ofAddUnits h₂

full_name: Subgroup.unit_eq_unit_of_mem_ofUnits
code: @[to_additive]
lemma unit_eq_unit_of_mem_ofUnits (S : Subgroup Mˣ) {x : M} (h₁ : IsUnit x)
    (h₂ : x ∈ S.ofUnits) : h₁.unit = S.unit_of_mem_ofUnits h₂ 
goal: h₁.unit = S.unit_of_mem_ofUnits h₂

full_name: AddSubgroup.addUnit_mem_of_mem_ofAddUnits
code: @[to_additive]
lemma unit_mem_of_mem_ofUnits (S : Subgroup Mˣ) {x : M} {h₁ : IsUnit x}
    (h₂ : x ∈ S.ofUnits) : h₁.unit ∈ S 
goal: h₁.addUnit ∈ S

full_name: Subgroup.unit_mem_of_mem_ofUnits
code: @[to_additive]
lemma unit_mem_of_mem_ofUnits (S : Subgroup Mˣ) {x : M} {h₁ : IsUnit x}
    (h₂ : x ∈ S.ofUnits) : h₁.unit ∈ S 
goal: h₁.unit ∈ S

full_name: AddSubgroup.mem_ofAddUnits_of_isAddUnit_of_addUnit_mem
code: @[to_additive]
lemma mem_ofUnits_of_isUnit_of_unit_mem (S : Subgroup Mˣ) {x : M} (h₁ : IsUnit x)
    (h₂ : h₁.unit ∈ S) : x ∈ S.ofUnits 
goal: x ∈ S.ofAddUnits

full_name: Subgroup.mem_ofUnits_of_isUnit_of_unit_mem
code: @[to_additive]
lemma mem_ofUnits_of_isUnit_of_unit_mem (S : Subgroup Mˣ) {x : M} (h₁ : IsUnit x)
    (h₂ : h₁.unit ∈ S) : x ∈ S.ofUnits 
goal: x ∈ S.ofUnits

full_name: Subgroup.mem_ofUnits_iff_exists_isUnit
code: @[to_additive]
lemma mem_ofUnits_iff_exists_isUnit (S : Subgroup Mˣ) (x : M) :
    x ∈ S.ofUnits ↔ ∃ h : IsUnit x, h.unit ∈ S 
goal: x ∈ S.ofUnits ↔ ∃ (h : IsUnit x), h.unit ∈ S

full_name: AddSubgroup.mem_ofAddUnits_iff_exists_isAddUnit
code: @[to_additive]
lemma mem_ofUnits_iff_exists_isUnit (S : Subgroup Mˣ) (x : M) :
    x ∈ S.ofUnits ↔ ∃ h : IsUnit x, h.unit ∈ S 
goal: x ∈ S.ofAddUnits ↔ ∃ (h : IsAddUnit x), h.addUnit ∈ S

full_name: AddSubgroup.ofAddUnitsEquivType
code: /-- The equivalence between the coercion of a subgroup `S` of `Mˣ` to a submonoid of `M` and
the subgroup itself as a type. -/
@[to_additive " The equivalence between the coercion of an additive subgroup `S` of
`Mˣ` to an additive submonoid of `M` and the additive subgroup itself as a type. "]
noncomputable def ofUnitsEquivType (S : Subgroup Mˣ) : S.ofUnits ≃* S 
goal: ↥S.ofAddUnits ≃+ ↥S

full_name: Subgroup.ofUnitsEquivType
code: /-- The equivalence between the coercion of a subgroup `S` of `Mˣ` to a submonoid of `M` and
the subgroup itself as a type. -/
@[to_additive " The equivalence between the coercion of an additive subgroup `S` of
`Mˣ` to an additive submonoid of `M` and the additive subgroup itself as a type. "]
noncomputable def ofUnitsEquivType (S : Subgroup Mˣ) : S.ofUnits ≃* S 
goal: ↥S.ofUnits ≃* ↥S

full_name: Subgroup.ofUnits_bot
code: @[to_additive (attr := simp)]
lemma ofUnits_bot : (⊥ : Subgroup Mˣ).ofUnits = ⊥ 
goal: ⊥.ofUnits = ⊥

full_name: AddSubgroup.ofAddUnits_bot
code: @[to_additive (attr := simp)]
lemma ofUnits_bot : (⊥ : Subgroup Mˣ).ofUnits = ⊥ 
goal: ⊥.ofAddUnits = ⊥

full_name: AddSubgroup.ofAddUnits_inf
code: @[to_additive]
lemma ofUnits_inf (S T : Subgroup Mˣ) : (S ⊔ T).ofUnits = S.ofUnits ⊔ T.ofUnits 
goal: (S ⊔ T).ofAddUnits = S.ofAddUnits ⊔ T.ofAddUnits

full_name: Subgroup.ofUnits_inf
code: @[to_additive]
lemma ofUnits_inf (S T : Subgroup Mˣ) : (S ⊔ T).ofUnits = S.ofUnits ⊔ T.ofUnits 
goal: (S ⊔ T).ofUnits = S.ofUnits ⊔ T.ofUnits

full_name: Subgroup.ofUnits_sSup
code: @[to_additive]
lemma ofUnits_sSup (s : Set (Subgroup Mˣ)) : (sSup s).ofUnits = ⨆ S ∈ s, S.ofUnits 
goal: (sSup s).ofUnits = ⨆ S ∈ s, S.ofUnits

full_name: AddSubgroup.ofAddUnits_sSup
code: @[to_additive]
lemma ofUnits_sSup (s : Set (Subgroup Mˣ)) : (sSup s).ofUnits = ⨆ S ∈ s, S.ofUnits 
goal: (sSup s).ofAddUnits = ⨆ S ∈ s, S.ofAddUnits

full_name: AddSubgroup.ofAddUnits_iSup
code: @[to_additive]
lemma ofUnits_iSup {ι : Sort*} {f : ι → Subgroup Mˣ} :
    (iSup f).ofUnits = ⨆ (i : ι), (f i).ofUnits 
goal: (iSup f).ofAddUnits = ⨆ i, (f i).ofAddUnits

full_name: Subgroup.ofUnits_iSup
code: @[to_additive]
lemma ofUnits_iSup {ι : Sort*} {f : ι → Subgroup Mˣ} :
    (iSup f).ofUnits = ⨆ (i : ι), (f i).ofUnits 
goal: (iSup f).ofUnits = ⨆ i, (f i).ofUnits

full_name: Subgroup.ofUnits_iSup₂
code: @[to_additive]
lemma ofUnits_iSup₂ {ι : Sort*} {κ : ι → Sort*} (f : (i : ι) → κ i → Subgroup Mˣ) :
    (⨆ (i : ι), ⨆ (j : κ i), f i j).ofUnits = ⨆ (i : ι), ⨆ (j : κ i), (f i j).ofUnits 
goal: (⨆ i, ⨆ j, f i j).ofUnits = ⨆ i, ⨆ j, (f i j).ofUnits

full_name: AddSubgroup.ofAddUnits_iSup₂
code: @[to_additive]
lemma ofUnits_iSup₂ {ι : Sort*} {κ : ι → Sort*} (f : (i : ι) → κ i → Subgroup Mˣ) :
    (⨆ (i : ι), ⨆ (j : κ i), f i j).ofUnits = ⨆ (i : ι), ⨆ (j : κ i), (f i j).ofUnits 
goal: (⨆ i, ⨆ j, f i j).ofAddUnits = ⨆ i, ⨆ j, (f i j).ofAddUnits

full_name: AddSubgroup.ofAddUnits_injective
code: @[to_additive]
lemma ofUnits_injective : Function.Injective (ofUnits (M := M)) 
goal: Function.Injective AddSubgroup.ofAddUnits

full_name: Subgroup.ofUnits_injective
code: @[to_additive]
lemma ofUnits_injective : Function.Injective (ofUnits (M := M)) 
goal: Function.Injective Subgroup.ofUnits

full_name: Subgroup.ofUnits_sup_units
code: @[to_additive (attr := simp)]
lemma ofUnits_sup_units (S T : Subgroup Mˣ) : (S.ofUnits ⊔ T.ofUnits).units = S ⊔ T 
goal: (S.ofUnits ⊔ T.ofUnits).units = S ⊔ T

full_name: AddSubgroup.ofAddUnits_sup_addUnits
code: @[to_additive (attr := simp)]
lemma ofUnits_sup_units (S T : Subgroup Mˣ) : (S.ofUnits ⊔ T.ofUnits).units = S ⊔ T 
goal: (S.ofAddUnits ⊔ T.ofAddUnits).addUnits = S ⊔ T

full_name: AddSubgroup.ofAddUnits_inf_addUnits
code: @[to_additive (attr := simp)]
lemma ofUnits_inf_units (S T : Subgroup Mˣ) : (S.ofUnits ⊓ T.ofUnits).units = S ⊓ T 
goal: (S.ofAddUnits ⊓ T.ofAddUnits).addUnits = S ⊓ T

full_name: Subgroup.ofUnits_inf_units
code: @[to_additive (attr := simp)]
lemma ofUnits_inf_units (S T : Subgroup Mˣ) : (S.ofUnits ⊓ T.ofUnits).units = S ⊓ T 
goal: (S.ofUnits ⊓ T.ofUnits).units = S ⊓ T

full_name: Subgroup.ofUnits_right_inverse
code: @[to_additive]
lemma ofUnits_right_inverse :
    Function.RightInverse (ofUnits (M := M)) (Submonoid.units (M := M)) 
goal: Function.RightInverse Subgroup.ofUnits Submonoid.units

full_name: AddSubgroup.ofAddUnits_right_inverse
code: @[to_additive]
lemma ofUnits_right_inverse :
    Function.RightInverse (ofUnits (M := M)) (Submonoid.units (M := M)) 
goal: Function.RightInverse AddSubgroup.ofAddUnits AddSubmonoid.addUnits

full_name: Subgroup.ofUnits_strictMono
code: @[to_additive]
lemma ofUnits_strictMono : StrictMono (ofUnits (M := M)) 
goal: StrictMono Subgroup.ofUnits

full_name: AddSubgroup.ofAddUnits_strictMono
code: @[to_additive]
lemma ofUnits_strictMono : StrictMono (ofUnits (M := M)) 
goal: StrictMono AddSubgroup.ofAddUnits

full_name: Subgroup.ofUnits_le_ofUnits_iff
code: lemma ofUnits_le_ofUnits_iff {S T : Subgroup Mˣ} : S.ofUnits ≤ T.ofUnits ↔ S ≤ T 
goal: S.ofUnits ≤ T.ofUnits ↔ S ≤ T

full_name: AddSubgroup.ofAddUnitsTopEquiv
code: /-- The equivalence between the top subgroup of `Mˣ` coerced to a submonoid `M` and the
units of `M`. -/
@[to_additive " The equivalence between the additive subgroup of additive units of
`S` and the additive submonoid of additive unit elements of `S`.  "]
noncomputable def ofUnitsTopEquiv : (⊤ : Subgroup Mˣ).ofUnits ≃* Mˣ 
goal: ↥⊤.ofAddUnits ≃+ AddUnits M

full_name: Subgroup.ofUnitsTopEquiv
code: /-- The equivalence between the top subgroup of `Mˣ` coerced to a submonoid `M` and the
units of `M`. -/
@[to_additive " The equivalence between the additive subgroup of additive units of
`S` and the additive submonoid of additive unit elements of `S`.  "]
noncomputable def ofUnitsTopEquiv : (⊤ : Subgroup Mˣ).ofUnits ≃* Mˣ 
goal: ↥⊤.ofUnits ≃* Mˣ

full_name: Subgroup.mem_units_iff_val_mem
code: @[to_additive]
lemma mem_units_iff_val_mem (H : Subgroup G) (x : Gˣ) : x ∈ H.units ↔ (x : G) ∈ H 
goal: x ∈ H.units ↔ ↑x ∈ H

full_name: AddSubgroup.mem_addUnits_iff_val_mem
code: @[to_additive]
lemma mem_units_iff_val_mem (H : Subgroup G) (x : Gˣ) : x ∈ H.units ↔ (x : G) ∈ H 
goal: x ∈ H.addUnits ↔ ↑x ∈ H

full_name: Subgroup.mem_ofUnits_iff_toUnits_mem
code: @[to_additive]
lemma mem_ofUnits_iff_toUnits_mem (H : Subgroup Gˣ) (x : G) : x ∈ H.ofUnits ↔ (toUnits x) ∈ H 
goal: x ∈ H.ofUnits ↔ toUnits x ∈ H

full_name: AddSubgroup.mem_ofAddUnits_iff_toAddUnits_mem
code: @[to_additive]
lemma mem_ofUnits_iff_toUnits_mem (H : Subgroup Gˣ) (x : G) : x ∈ H.ofUnits ↔ (toUnits x) ∈ H 
goal: x ∈ H.ofAddUnits ↔ toAddUnits x ∈ H

full_name: AddSubgroup.mem_iff_toAddUnits_mem_addUnits
code: @[to_additive (attr := simp)]
lemma mem_iff_toUnits_mem_units (H : Subgroup G) (x : G) : toUnits x ∈ H.units ↔ x ∈ H 
goal: toAddUnits x ∈ H.addUnits ↔ x ∈ H

full_name: Subgroup.mem_iff_toUnits_mem_units
code: @[to_additive (attr := simp)]
lemma mem_iff_toUnits_mem_units (H : Subgroup G) (x : G) : toUnits x ∈ H.units ↔ x ∈ H 
goal: toUnits x ∈ H.units ↔ x ∈ H

full_name: Subgroup.val_mem_ofUnits_iff_mem
code: @[to_additive (attr := simp)]
lemma val_mem_ofUnits_iff_mem (H : Subgroup Gˣ) (x : Gˣ) : (x : G) ∈ H.ofUnits ↔ x ∈ H 
goal: ↑x ∈ H.ofUnits ↔ x ∈ H

full_name: AddSubgroup.val_mem_ofAddUnits_iff_mem
code: @[to_additive (attr := simp)]
lemma val_mem_ofUnits_iff_mem (H : Subgroup Gˣ) (x : Gˣ) : (x : G) ∈ H.ofUnits ↔ x ∈ H 
goal: ↑x ∈ H.ofAddUnits ↔ x ∈ H

full_name: AddSubgroup.addUnitsEquivSelf
code: /-- The equivalence between the greatest subgroup of units contained within `T` and `T` itself. -/
@[to_additive " The equivalence between the greatest subgroup of additive units
contained within `T` and `T` itself. "]
def unitsEquivSelf (H : Subgroup G) : H.units ≃* H 
goal: ↥H.addUnits ≃+ ↥H

full_name: Subgroup.unitsEquivSelf
code: /-- The equivalence between the greatest subgroup of units contained within `T` and `T` itself. -/
@[to_additive " The equivalence between the greatest subgroup of additive units
contained within `T` and `T` itself. "]
def unitsEquivSelf (H : Subgroup G) : H.units ≃* H 
goal: ↥H.units ≃* ↥H