Module docstring
{"# Units in semirings and rings
"}
{"# Units in semirings and rings
"}
Units.instNeg
      instance
     : Neg αˣ
        /-- Each element of the group of units of a ring has an additive inverse. -/
instance : Neg αˣ :=
  ⟨fun u => ⟨-↑u, -↑u⁻¹, by simp, by simp⟩⟩
        Units.val_neg
      theorem
     (u : αˣ) : (↑(-u) : α) = -u
        
      Units.coe_neg_one
      theorem
     : ((-1 : αˣ) : α) = -1
        @[simp, norm_cast]
protected theorem coe_neg_one : ((-1 : αˣ) : α) = -1 :=
  rfl
        Units.instHasDistribNeg
      instance
     : HasDistribNeg αˣ
        instance : HasDistribNeg αˣ :=
  Units.ext.hasDistribNeg _ Units.val_neg Units.val_mul
        Units.neg_divp
      theorem
     (a : α) (u : αˣ) : -(a /ₚ u) = -a /ₚ u
        
      Units.divp_add_divp_same
      theorem
     (a b : α) (u : αˣ) : a /ₚ u + b /ₚ u = (a + b) /ₚ u
        @[field_simps 1010]
theorem divp_add_divp_same (a b : α) (u : αˣ) : a /ₚ u + b /ₚ u = (a + b) /ₚ u := by
  simp only [divp, add_mul]
        Units.divp_sub_divp_same
      theorem
     (a b : α) (u : αˣ) : a /ₚ u - b /ₚ u = (a - b) /ₚ u
        @[field_simps 1010]
theorem divp_sub_divp_same (a b : α) (u : αˣ) : a /ₚ u - b /ₚ u = (a - b) /ₚ u := by
  rw [sub_eq_add_neg, sub_eq_add_neg, neg_divp, divp_add_divp_same]
        Units.add_divp
      theorem
     (a b : α) (u : αˣ) : a + b /ₚ u = (a * u + b) /ₚ u
        @[field_simps]
theorem add_divp (a b : α) (u : αˣ) : a + b /ₚ u = (a * u + b) /ₚ u := by
  simp only [divp, add_mul, Units.mul_inv_cancel_right]
        Units.sub_divp
      theorem
     (a b : α) (u : αˣ) : a - b /ₚ u = (a * u - b) /ₚ u
        @[field_simps]
theorem sub_divp (a b : α) (u : αˣ) : a - b /ₚ u = (a * u - b) /ₚ u := by
  simp only [divp, sub_mul, Units.mul_inv_cancel_right]
        Units.divp_add
      theorem
     (a b : α) (u : αˣ) : a /ₚ u + b = (a + b * u) /ₚ u
        @[field_simps]
theorem divp_add (a b : α) (u : αˣ) : a /ₚ u + b = (a + b * u) /ₚ u := by
  simp only [divp, add_mul, Units.mul_inv_cancel_right]
        Units.divp_sub
      theorem
     (a b : α) (u : αˣ) : a /ₚ u - b = (a - b * u) /ₚ u
        @[field_simps]
theorem divp_sub (a b : α) (u : αˣ) : a /ₚ u - b = (a - b * u) /ₚ u := by
  simp only [divp, sub_mul, sub_right_inj]
  rw [mul_assoc, Units.mul_inv, mul_one]
        Units.map_neg
      theorem
     {F : Type*} [Ring β] [FunLike F α β] [RingHomClass F α β] (f : F) (u : αˣ) :
  map (f : α →* β) (-u) = -map (f : α →* β) u
        @[simp]
protected theorem map_neg {F : Type*} [Ring β] [FunLike F α β] [RingHomClass F α β]
    (f : F) (u : αˣ) : map (f : α →* β) (-u) = -map (f : α →* β) u :=
  ext (by simp only [coe_map, Units.val_neg, MonoidHom.coe_coe, map_neg])
        Units.map_neg_one
      theorem
     {F : Type*} [Ring β] [FunLike F α β] [RingHomClass F α β] (f : F) : map (f : α →* β) (-1) = -1
        protected theorem map_neg_one {F : Type*} [Ring β] [FunLike F α β] [RingHomClass F α β]
    (f : F) : map (f : α →* β) (-1) = -1 := by
  simp only [Units.map_neg, map_one]
        IsUnit.neg
      theorem
     [Monoid α] [HasDistribNeg α] {a : α} : IsUnit a → IsUnit (-a)
        theorem IsUnit.neg [Monoid α] [HasDistribNeg α] {a : α} : IsUnit a → IsUnit (-a)
  | ⟨x, hx⟩ => hx ▸ (-x).isUnit
        IsUnit.neg_iff
      theorem
     [Monoid α] [HasDistribNeg α] (a : α) : IsUnit (-a) ↔ IsUnit a
        @[simp]
theorem IsUnit.neg_iff [Monoid α] [HasDistribNeg α] (a : α) : IsUnitIsUnit (-a) ↔ IsUnit a :=
  ⟨fun h => neg_neg a ▸ h.neg, IsUnit.neg⟩
        isUnit_neg_one
      theorem
     [Monoid α] [HasDistribNeg α] : IsUnit (-1 : α)
        theorem isUnit_neg_one [Monoid α] [HasDistribNeg α] : IsUnit (-1 : α) := isUnit_one.neg
        IsUnit.sub_iff
      theorem
     [Ring α] {x y : α} : IsUnit (x - y) ↔ IsUnit (y - x)
        theorem IsUnit.sub_iff [Ring α] {x y : α} : IsUnitIsUnit (x - y) ↔ IsUnit (y - x) :=
  (IsUnit.neg_iff _).symm.trans <| neg_sub x y ▸ Iff.rfl
        Units.divp_add_divp
      theorem
     [CommSemiring α] (a b : α) (u₁ u₂ : αˣ) : a /ₚ u₁ + b /ₚ u₂ = (a * u₂ + u₁ * b) /ₚ (u₁ * u₂)
        @[field_simps]
theorem divp_add_divp [CommSemiring α] (a b : α) (u₁ u₂ : αˣ) :
    a /ₚ u₁ + b /ₚ u₂ = (a * u₂ + u₁ * b) /ₚ (u₁ * u₂) := by
  simp only [divp, add_mul, mul_inv_rev, val_mul]
  rw [mul_comm (↑u₁ * b), mul_comm b]
  rw [← mul_assoc, ← mul_assoc, mul_assoc a, mul_assoc (↑u₂⁻¹ : α), mul_inv, inv_mul, mul_one,
    mul_one]
        Units.divp_sub_divp
      theorem
     [CommRing α] (a b : α) (u₁ u₂ : αˣ) : a /ₚ u₁ - b /ₚ u₂ = (a * u₂ - u₁ * b) /ₚ (u₁ * u₂)
        @[field_simps]
theorem divp_sub_divp [CommRing α] (a b : α) (u₁ u₂ : αˣ) :
    a /ₚ u₁ - b /ₚ u₂ = (a * u₂ - u₁ * b) /ₚ (u₁ * u₂) := by
  simp only [sub_eq_add_neg, neg_divp, divp_add_divp, mul_neg]
        Units.add_eq_mul_one_add_div
      theorem
     [Semiring R] {a : Rˣ} {b : R} : ↑a + b = a * (1 + ↑a⁻¹ * b)
        theorem add_eq_mul_one_add_div [Semiring R] {a : Rˣ} {b : R} : ↑a + b = a * (1 + ↑a⁻¹ * b) := by
  rw [mul_add, mul_one, ← mul_assoc, Units.mul_inv, one_mul]
        RingHom.isUnit_map
      theorem
     (f : α →+* β) {a : α} : IsUnit a → IsUnit (f a)
        theorem isUnit_map (f : α →+* β) {a : α} : IsUnit a → IsUnit (f a) :=
  IsUnit.map f