File: Mathlib/Algebra/Ring/Units.lean

full_name: Units.instNeg
code: /-- Each element of the group of units of a ring has an additive inverse. -/
instance : Neg αˣ 
goal: Neg αˣ

full_name: Units.val_neg
code: /-- Representing an element of a ring's unit group as an element of the ring commutes with
    mapping this element to its additive inverse. -/
@[simp, norm_cast]
protected theorem val_neg (u : αˣ) : (↑(-u) : α) = -u 
goal: ↑(-u) = -↑u

full_name: Units.coe_neg_one
code: @[simp, norm_cast]
protected theorem coe_neg_one : ((-1 : αˣ) : α) = -1 
goal: ↑(-1) = -1

full_name: Units.instHasDistribNeg
code: instance : HasDistribNeg αˣ 
goal: HasDistribNeg αˣ

full_name: Units.neg_divp
code: @[field_simps]
theorem neg_divp (a : α) (u : αˣ) : -(a /ₚ u) = -a /ₚ u 
goal: -(a /ₚ u) = -a /ₚ u

full_name: Units.divp_add_divp_same
code: @[field_simps 1010]
theorem divp_add_divp_same (a b : α) (u : αˣ) : a /ₚ u + b /ₚ u = (a + b) /ₚ u 
goal: a /ₚ u + b /ₚ u = (a + b) /ₚ u

full_name: Units.divp_sub_divp_same
code: @[field_simps 1010]
theorem divp_sub_divp_same (a b : α) (u : αˣ) : a /ₚ u - b /ₚ u = (a - b) /ₚ u 
goal: a /ₚ u - b /ₚ u = (a - b) /ₚ u

full_name: Units.add_divp
code: @[field_simps]
theorem add_divp (a b : α) (u : αˣ) : a + b /ₚ u = (a * u + b) /ₚ u 
goal: a + b /ₚ u = (a * ↑u + b) /ₚ u

full_name: Units.sub_divp
code: @[field_simps]
theorem sub_divp (a b : α) (u : αˣ) : a - b /ₚ u = (a * u - b) /ₚ u 
goal: a - b /ₚ u = (a * ↑u - b) /ₚ u

full_name: Units.divp_add
code: @[field_simps]
theorem divp_add (a b : α) (u : αˣ) : a /ₚ u + b = (a + b * u) /ₚ u 
goal: a /ₚ u + b = (a + b * ↑u) /ₚ u

full_name: Units.divp_sub
code: @[field_simps]
theorem divp_sub (a b : α) (u : αˣ) : a /ₚ u - b = (a - b * u) /ₚ u 
goal: a /ₚ u - b = (a - b * ↑u) /ₚ u

full_name: Units.map_neg
code: @[simp]
protected theorem map_neg {F : Type*} [Ring β] [FunLike F α β] [RingHomClass F α β]
    (f : F) (u : αˣ) : map (f : α →* β) (-u) = -map (f : α →* β) u 
goal: (Units.map ↑f) (-u) = -(Units.map ↑f) u

full_name: Units.map_neg_one
code: protected theorem map_neg_one {F : Type*} [Ring β] [FunLike F α β] [RingHomClass F α β]
    (f : F) : map (f : α →* β) (-1) = -1 
goal: (Units.map ↑f) (-1) = -1

full_name: IsUnit.neg
code: theorem IsUnit.neg [Monoid α] [HasDistribNeg α] {a : α} : IsUnit a → IsUnit (-a)
  
goal: IsUnit a → IsUnit (-a)

full_name: IsUnit.neg_iff
code: @[simp]
theorem IsUnit.neg_iff [Monoid α] [HasDistribNeg α] (a : α) : IsUnit (-a) ↔ IsUnit a 
goal: IsUnit (-a) ↔ IsUnit a

full_name: isUnit_neg_one
code: theorem isUnit_neg_one [Monoid α] [HasDistribNeg α] : IsUnit (-1 : α) 
goal: IsUnit (-1)

full_name: IsUnit.sub_iff
code: theorem IsUnit.sub_iff [Ring α] {x y : α} : IsUnit (x - y) ↔ IsUnit (y - x) 
goal: IsUnit (x - y) ↔ IsUnit (y - x)

full_name: Units.divp_add_divp
code: @[field_simps]
theorem divp_add_divp [CommRing α] (a b : α) (u₁ u₂ : αˣ) :
    a /ₚ u₁ + b /ₚ u₂ = (a * u₂ + u₁ * b) /ₚ (u₁ * u₂) 
goal: a /ₚ u₁ + b /ₚ u₂ = (a * ↑u₂ + ↑u₁ * b) /ₚ (u₁ * u₂)

full_name: Units.divp_sub_divp
code: @[field_simps]
theorem divp_sub_divp [CommRing α] (a b : α) (u₁ u₂ : αˣ) :
    a /ₚ u₁ - b /ₚ u₂ = (a * u₂ - u₁ * b) /ₚ (u₁ * u₂) 
goal: a /ₚ u₁ - b /ₚ u₂ = (a * ↑u₂ - ↑u₁ * b) /ₚ (u₁ * u₂)

full_name: Units.add_eq_mul_one_add_div
code: theorem add_eq_mul_one_add_div [Semiring R] {a : Rˣ} {b : R} : ↑a + b = a * (1 + ↑a⁻¹ * b) 
goal: ↑a + b = ↑a * (1 + ↑a⁻¹ * b)