File: Mathlib/Algebra/Group/Invertible/Basic.lean

full_name: val_unitOfInvertible
code: /-- An `Invertible` element is a unit. -/
@[simps]
def unitOfInvertible [Monoid α] (a : α) [Invertible a] : αˣ 
goal: ↑(unitOfInvertible a) = a

full_name: unitOfInvertible
code: /-- An `Invertible` element is a unit. -/
@[simps]
def unitOfInvertible [Monoid α] (a : α) [Invertible a] : αˣ 
goal: αˣ

full_name: val_inv_unitOfInvertible
code: /-- An `Invertible` element is a unit. -/
@[simps]
def unitOfInvertible [Monoid α] (a : α) [Invertible a] : αˣ 
goal: ↑(unitOfInvertible a)⁻¹ = ⅟a

full_name: isUnit_of_invertible
code: theorem isUnit_of_invertible [Monoid α] (a : α) [Invertible a] : IsUnit a 
goal: IsUnit a

full_name: Units.invertible
code: /-- Units are invertible in their associated monoid. -/
def Units.invertible [Monoid α] (u : αˣ) :
    Invertible (u : α) 
goal: Invertible ↑u

full_name: invOf_units
code: @[simp]
theorem invOf_units [Monoid α] (u : αˣ) [Invertible (u : α)] : ⅟ (u : α) = ↑u⁻¹ 
goal: ⅟↑u = ↑u⁻¹

full_name: IsUnit.nonempty_invertible
code: theorem IsUnit.nonempty_invertible [Monoid α] {a : α} (h : IsUnit a) : Nonempty (Invertible a) 
goal: Nonempty (Invertible a)

full_name: IsUnit.invertible
code: /-- Convert `IsUnit` to `Invertible` using `Classical.choice`.

Prefer `casesI h.nonempty_invertible` over `letI := h.invertible` if you want to avoid choice. -/
noncomputable def IsUnit.invertible [Monoid α] {a : α} (h : IsUnit a) : Invertible a 
goal: Invertible a

full_name: nonempty_invertible_iff_isUnit
code: @[simp]
theorem nonempty_invertible_iff_isUnit [Monoid α] (a : α) : Nonempty (Invertible a) ↔ IsUnit a 
goal: Nonempty (Invertible a) ↔ IsUnit a

full_name: Commute.invOf_right
code: theorem Commute.invOf_right [Monoid α] {a b : α} [Invertible b] (h : Commute a b) :
    Commute a (⅟ b) 
goal: Commute a ⅟b

full_name: Commute.invOf_left
code: theorem Commute.invOf_left [Monoid α] {a b : α} [Invertible b] (h : Commute b a) :
    Commute (⅟ b) a 
goal: Commute (⅟b) a

full_name: commute_invOf
code: theorem commute_invOf {M : Type*} [One M] [Mul M] (m : M) [Invertible m] : Commute m (⅟ m) 
goal: Commute m ⅟m

full_name: invertibleOfInvertibleMul
code: /-- This is the `Invertible` version of `Units.isUnit_units_mul` -/
abbrev invertibleOfInvertibleMul (a b : α) [Invertible a] [Invertible (a * b)] : Invertible b 
goal: Invertible b

full_name: invertibleOfMulInvertible
code: /-- This is the `Invertible` version of `Units.isUnit_mul_units` -/
abbrev invertibleOfMulInvertible (a b : α) [Invertible (a * b)] [Invertible b] : Invertible a 
goal: Invertible a

full_name: Invertible.mulLeft_apply
code: /-- `invertibleOfInvertibleMul` and `invertibleMul` as an equivalence. -/
@[simps apply symm_apply]
def Invertible.mulLeft {a : α} (_ : Invertible a) (b : α) : Invertible b ≃ Invertible (a * b) 
goal: ∀ (x : Invertible a) (b : α) (x_1 : Invertible b), (x.mulLeft b) x_1 = invertibleMul a b

full_name: Invertible.mulLeft
code: /-- `invertibleOfInvertibleMul` and `invertibleMul` as an equivalence. -/
@[simps apply symm_apply]
def Invertible.mulLeft {a : α} (_ : Invertible a) (b : α) : Invertible b ≃ Invertible (a * b) 
goal: Invertible a → (b : α) → Invertible b ≃ Invertible (a * b)

full_name: Invertible.mulLeft_symm_apply
code: /-- `invertibleOfInvertibleMul` and `invertibleMul` as an equivalence. -/
@[simps apply symm_apply]
def Invertible.mulLeft {a : α} (_ : Invertible a) (b : α) : Invertible b ≃ Invertible (a * b) 
goal: ∀ (x : Invertible a) (b : α) (x_1 : Invertible (a * b)), (x.mulLeft b).symm x_1 = invertibleOfInvertibleMul a b

full_name: Invertible.mulRight
code: /-- `invertibleOfMulInvertible` and `invertibleMul` as an equivalence. -/
@[simps apply symm_apply]
def Invertible.mulRight (a : α) {b : α} (_ : Invertible b) : Invertible a ≃ Invertible (a * b) 
goal: Invertible b → Invertible a ≃ Invertible (a * b)

full_name: Invertible.mulRight_apply
code: /-- `invertibleOfMulInvertible` and `invertibleMul` as an equivalence. -/
@[simps apply symm_apply]
def Invertible.mulRight (a : α) {b : α} (_ : Invertible b) : Invertible a ≃ Invertible (a * b) 
goal: ∀ (x : Invertible b) (x_1 : Invertible a), (Invertible.mulRight a x) x_1 = invertibleMul a b

full_name: Invertible.mulRight_symm_apply
code: /-- `invertibleOfMulInvertible` and `invertibleMul` as an equivalence. -/
@[simps apply symm_apply]
def Invertible.mulRight (a : α) {b : α} (_ : Invertible b) : Invertible a ≃ Invertible (a * b) 
goal: ∀ (x : Invertible b) (x_1 : Invertible (a * b)), (Invertible.mulRight a x).symm x_1 = invertibleOfMulInvertible a b

full_name: invertiblePow
code: instance invertiblePow (m : α) [Invertible m] (n : ℕ) : Invertible (m ^ n) 
goal: Invertible (m ^ n)

full_name: invOf_pow
code: lemma invOf_pow (m : α) [Invertible m] (n : ℕ) [Invertible (m ^ n)] : ⅟ (m ^ n) = ⅟ m ^ n 
goal: ⅟(m ^ n) = ⅟m ^ n

full_name: invertibleOfPowEqOne
code: /-- If `x ^ n = 1` then `x` has an inverse, `x^(n - 1)`. -/
def invertibleOfPowEqOne (x : α) (n : ℕ) (hx : x ^ n = 1) (hn : n ≠ 0) : Invertible x 
goal: Invertible x

full_name: Invertible.map
code: /-- Monoid homs preserve invertibility. -/
def Invertible.map {R : Type*} {S : Type*} {F : Type*} [MulOneClass R] [MulOneClass S]
    [FunLike F R S] [MonoidHomClass F R S] (f : F) (r : R) [Invertible r] :
    Invertible (f r) 
goal: Invertible (f r)

full_name: map_invOf
code: /-- Note that the `Invertible (f r)` argument can be satisfied by using `letI := Invertible.map f r`
before applying this lemma. -/
theorem map_invOf {R : Type*} {S : Type*} {F : Type*} [MulOneClass R] [Monoid S]
    [FunLike F R S] [MonoidHomClass F R S] (f : F) (r : R)
    [Invertible r] [ifr : Invertible (f r)] :
    f (⅟ r) = ⅟ (f r) 
goal: f ⅟r = ⅟(f r)

full_name: Invertible.ofLeftInverse
code: /-- If a function `f : R → S` has a left-inverse that is a monoid hom,
  then `r : R` is invertible if `f r` is.

The inverse is computed as `g (⅟(f r))` -/
@[simps! (config := .lemmasOnly)]
def Invertible.ofLeftInverse {R : Type*} {S : Type*} {G : Type*} [MulOneClass R] [MulOneClass S]
    [FunLike G S R] [MonoidHomClass G S R] (f : R → S) (g : G) (r : R)
    (h : Function.LeftInverse g f) [Invertible (f r)] : Invertible r 
goal: Invertible r

full_name: Invertible.ofLeftInverse_invOf
code: /-- If a function `f : R → S` has a left-inverse that is a monoid hom,
  then `r : R` is invertible if `f r` is.

The inverse is computed as `g (⅟(f r))` -/
@[simps! (config := .lemmasOnly)]
def Invertible.ofLeftInverse {R : Type*} {S : Type*} {G : Type*} [MulOneClass R] [MulOneClass S]
    [FunLike G S R] [MonoidHomClass G S R] (f : R → S) (g : G) (r : R)
    (h : Function.LeftInverse g f) [Invertible (f r)] : Invertible r 
goal: ⅟r = ⅟(g (f r))

full_name: invertibleEquivOfLeftInverse_apply
code: /-- Invertibility on either side of a monoid hom with a left-inverse is equivalent. -/
@[simps]
def invertibleEquivOfLeftInverse {R : Type*} {S : Type*} {F G : Type*} [Monoid R] [Monoid S]
    [FunLike F R S] [MonoidHomClass F R S] [FunLike G S R] [MonoidHomClass G S R]
    (f : F) (g : G) (r : R) (h : Function.LeftInverse g f) : Invertible (f r) ≃ Invertible r 
goal: ∀ (x : Invertible (f r)), (invertibleEquivOfLeftInverse f g r h) x = Invertible.ofLeftInverse (⇑f) g r h

full_name: invertibleEquivOfLeftInverse_symm_apply
code: /-- Invertibility on either side of a monoid hom with a left-inverse is equivalent. -/
@[simps]
def invertibleEquivOfLeftInverse {R : Type*} {S : Type*} {F G : Type*} [Monoid R] [Monoid S]
    [FunLike F R S] [MonoidHomClass F R S] [FunLike G S R] [MonoidHomClass G S R]
    (f : F) (g : G) (r : R) (h : Function.LeftInverse g f) : Invertible (f r) ≃ Invertible r 
goal: ∀ (x : Invertible r), (invertibleEquivOfLeftInverse f g r h).symm x = Invertible.map f r

full_name: invertibleEquivOfLeftInverse
code: /-- Invertibility on either side of a monoid hom with a left-inverse is equivalent. -/
@[simps]
def invertibleEquivOfLeftInverse {R : Type*} {S : Type*} {F G : Type*} [Monoid R] [Monoid S]
    [FunLike F R S] [MonoidHomClass F R S] [FunLike G S R] [MonoidHomClass G S R]
    (f : F) (g : G) (r : R) (h : Function.LeftInverse g f) : Invertible (f r) ≃ Invertible r 
goal: Invertible (f r) ≃ Invertible r