algebra.group.units | Mathlib porting status

(last sync)

feat(algebra/divisibility/basic): Dot notation aliases (#18698)

A few convenience shortcuts for dvd along with some simple nat lemmas. Also

Drop neg_dvd_of_dvd/dvd_of_neg_dvd/dvd_neg_of_dvd/dvd_of_dvd_neg in favor of the aforementioned shortcuts.
Remove explicit arguments to dvd_neg/neg_dvd.
Drop int.of_nat_dvd_of_dvd_nat_abs/int.dvd_nat_abs_of_of_nat_dvd because they are the two directions of int.coe_nat_dvd_left.
Move group_with_zero.to_cancel_monoid_with_zero from algebra.group_with_zero.units.basic back to algebra.group_with_zero.basic. It was erroneously moved during the Great Splits.

Diff

@@ -328,6 +328,17 @@ by rw [divp_eq_iff_mul_eq, divp_mul_eq_mul_divp, divp_eq_iff_mul_eq]
   (x /ₚ ux) * (y /ₚ uy) = (x * y) /ₚ (ux * uy) :=
 by rw [divp_mul_eq_mul_divp, divp_assoc', divp_divp_eq_divp_mul]
 
+variables [subsingleton αˣ] {a b : α}
+
+@[to_additive] lemma eq_one_of_mul_right (h : a * b = 1) : a = 1 :=
+congr_arg units.inv $ subsingleton.elim (units.mk _ _ (by rwa mul_comm) h) 1
+
+@[to_additive] lemma eq_one_of_mul_left (h : a * b = 1) : b = 1 :=
+congr_arg units.inv $ subsingleton.elim (units.mk _ _ h $ by rwa mul_comm) 1
+
+@[simp, to_additive] lemma mul_eq_one : a * b = 1 ↔ a = 1 ∧ b = 1 :=
+⟨λ h, ⟨eq_one_of_mul_right h, eq_one_of_mul_left h⟩, by { rintro ⟨rfl, rfl⟩, exact mul_one _ }⟩
+
 end comm_monoid
 
 /-!

chore(algebra/group/units): is_add_unit.decidable (#18439)

Missing to_additive

I had actually added this to mathlib4 3 months ago in leanprover-community/mathlib4@cbc083419c0aeee4e99154f304f5f8ac66bce0d8 (leanprover-community/mathlib4#549), and never noticed it wasn't in mathlib3.

mathlib4 hash-update placeholder pr: https://github.com/leanprover-community/mathlib4/pull/2278

Diff

@@ -458,6 +458,7 @@ lemma coe_inv_mul (h : is_unit a) : ↑(h.unit)⁻¹ * a = 1 := units.mul_inv _
 by convert h.unit.mul_inv
 
 /-- `is_unit x` is decidable if we can decide if `x` comes from `Mˣ`. -/
+@[to_additive "`is_add_unit x` is decidable if we can decide if `x` comes from `add_units M"]
 instance (x : M) [h : decidable (∃ u : Mˣ, ↑u = x)] : decidable (is_unit x) := h
 
 @[to_additive] lemma mul_left_inj (h : is_unit a) : b * a = c * a ↔ b = c :=

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2024-03-17-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

22f01ce4

Diff

@@ -127,7 +127,7 @@ theorem val_mk (a : α) (b h₁ h₂) : ↑(Units.mk a b h₁ h₂) = a :=
 @[ext, to_additive]
 theorem ext : Function.Injective (coe : αˣ → α)
   | ⟨v, i₁, vi₁, iv₁⟩, ⟨v', i₂, vi₂, iv₂⟩, e => by
-    change v = v' at e  <;> subst v' <;> congr <;>
+    change v = v' at e <;> subst v' <;> congr <;>
       simpa only [iv₂, vi₁, one_mul, mul_one] using mul_assoc i₂ v i₁
 #align units.ext Units.ext
 #align add_units.ext AddUnits.ext
@@ -780,7 +780,7 @@ theorem Units.isUnit_mul_units [Monoid M] (a : M) (u : Mˣ) : IsUnit (a * u) ↔
     (fun ⟨v, hv⟩ =>
       by
       have : IsUnit (a * ↑u * ↑u⁻¹) := by exists v * u⁻¹ <;> rw [← hv, Units.val_mul]
-      rwa [mul_assoc, Units.mul_inv, mul_one] at this )
+      rwa [mul_assoc, Units.mul_inv, mul_one] at this)
     fun v => v.mul u.IsUnit
 #align units.is_unit_mul_units Units.isUnit_mul_units
 #align add_units.is_add_unit_add_add_units AddUnits.isAddUnit_add_addUnits
@@ -795,7 +795,7 @@ theorem Units.isUnit_units_mul {M : Type _} [Monoid M] (u : Mˣ) (a : M) :
     (fun ⟨v, hv⟩ =>
       by
       have : IsUnit (↑u⁻¹ * (↑u * a)) := by exists u⁻¹ * v <;> rw [← hv, Units.val_mul]
-      rwa [← mul_assoc, Units.inv_mul, one_mul] at this )
+      rwa [← mul_assoc, Units.inv_mul, one_mul] at this)
     u.IsUnit.mul
 #align units.is_unit_units_mul Units.isUnit_units_mul
 #align add_units.is_add_unit_add_units_add AddUnits.isAddUnit_addUnits_add

bump to nightly-2023-09-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

5655435f

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2017 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau, Mario Carneiro, Johannes Hölzl, Chris Hughes, Jens Wagemaker, Jon Eugster
 -/
-import Mathbin.Algebra.Group.Basic
-import Mathbin.Logic.Unique
-import Mathbin.Tactic.Nontriviality
+import Algebra.Group.Basic
+import Logic.Unique
+import Tactic.Nontriviality
 
 #align_import algebra.group.units from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"

bump to nightly-2023-08-23-23

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

f612b9e0

Diff

@@ -102,16 +102,18 @@ def Simps.coe (u : αˣ) : α :=
 #align units.simps.coe Units.Simps.coe
 #align add_units.simps.coe AddUnits.Simps.coe
 
+#print Units.Simps.val_inv /-
 /-- See Note [custom simps projection] -/
 @[to_additive " See Note [custom simps projection] "]
-def Simps.coeInv (u : αˣ) : α :=
+def Simps.val_inv (u : αˣ) : α :=
   ↑u⁻¹
-#align units.simps.coe_inv Units.Simps.coeInv
-#align add_units.simps.coe_neg AddUnits.Simps.coeNeg
+#align units.simps.coe_inv Units.Simps.val_inv
+#align add_units.simps.coe_neg AddUnits.Simps.val_neg
+-/
 
-initialize_simps_projections Units (val → coe, as_prefix coe, inv → coeInv, as_prefix coeInv)
+initialize_simps_projections Units (val → coe, as_prefix coe, inv → val_inv, as_prefix val_inv)
 
-initialize_simps_projections AddUnits (val → coe, as_prefix coe, neg → coeNeg, as_prefix coeNeg)
+initialize_simps_projections AddUnits (val → coe, as_prefix coe, neg → val_neg, as_prefix val_neg)
 
 #print Units.val_mk /-
 @[simp, to_additive]

bump to nightly-2023-08-17-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

60285dcc

Diff

@@ -197,7 +197,7 @@ instance : Group αˣ :=
     one := 1
     mul_assoc := fun u₁ u₂ u₃ => ext <| mul_assoc u₁ u₂ u₃
     inv := Inv.inv
-    mul_left_inv := fun u => ext u.inv_val }
+    hMul_left_inv := fun u => ext u.inv_val }
 
 @[to_additive]
 instance {α} [CommMonoid α] : CommGroup αˣ :=
@@ -915,7 +915,7 @@ protected theorem mul_right_cancel (h : IsUnit b) : a * b = c * b → a = c :=
 #print IsUnit.mul_right_injective /-
 @[to_additive]
 protected theorem mul_right_injective (h : IsUnit a) : Injective ((· * ·) a) := fun _ _ =>
-  h.mul_left_cancel
+  h.hMul_left_cancel
 #align is_unit.mul_right_injective IsUnit.mul_right_injective
 #align is_add_unit.add_right_injective IsAddUnit.add_right_injective
 -/
@@ -923,7 +923,7 @@ protected theorem mul_right_injective (h : IsUnit a) : Injective ((· * ·) a) :
 #print IsUnit.mul_left_injective /-
 @[to_additive]
 protected theorem mul_left_injective (h : IsUnit b) : Injective (· * b) := fun _ _ =>
-  h.mul_right_cancel
+  h.hMul_right_cancel
 #align is_unit.mul_left_injective IsUnit.mul_left_injective
 #align is_add_unit.add_left_injective IsAddUnit.add_left_injective
 -/
@@ -963,7 +963,7 @@ variable {M : Type _}
 noncomputable def groupOfIsUnit [hM : Monoid M] (h : ∀ a : M, IsUnit a) : Group M :=
   { hM with
     inv := fun a => ↑(h a).Unit⁻¹
-    mul_left_inv := fun a => by
+    hMul_left_inv := fun a => by
       change ↑(h a).Unit⁻¹ * a = 1
       rw [Units.inv_mul_eq_iff_eq_mul, (h a).unit_spec, mul_one] }
 #align group_of_is_unit groupOfIsUnit
@@ -974,7 +974,7 @@ noncomputable def groupOfIsUnit [hM : Monoid M] (h : ∀ a : M, IsUnit a) : Grou
 noncomputable def commGroupOfIsUnit [hM : CommMonoid M] (h : ∀ a : M, IsUnit a) : CommGroup M :=
   { hM with
     inv := fun a => ↑(h a).Unit⁻¹
-    mul_left_inv := fun a => by
+    hMul_left_inv := fun a => by
       change ↑(h a).Unit⁻¹ * a = 1
       rw [Units.inv_mul_eq_iff_eq_mul, (h a).unit_spec, mul_one] }
 #align comm_group_of_is_unit commGroupOfIsUnit

bump to nightly-2023-07-20-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

9c56d0dd

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2017 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau, Mario Carneiro, Johannes Hölzl, Chris Hughes, Jens Wagemaker, Jon Eugster
-
-! This file was ported from Lean 3 source module algebra.group.units
-! leanprover-community/mathlib commit e8638a0fcaf73e4500469f368ef9494e495099b3
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Group.Basic
 import Mathbin.Logic.Unique
 import Mathbin.Tactic.Nontriviality
 
+#align_import algebra.group.units from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"
+
 /-!
 # Units (i.e., invertible elements) of a monoid

bump to nightly-2023-06-13-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

829520ac

Diff

@@ -55,7 +55,6 @@ structure Units (α : Type u) [Monoid α] where
 #align units Units
 -/
 
--- mathport name: «expr ˣ»
 postfix:1024 "ˣ" => Units
 
 #print AddUnits /-
@@ -117,11 +116,13 @@ initialize_simps_projections Units (val → coe, as_prefix coe, inv → coeInv,
 
 initialize_simps_projections AddUnits (val → coe, as_prefix coe, neg → coeNeg, as_prefix coeNeg)
 
+#print Units.val_mk /-
 @[simp, to_additive]
 theorem val_mk (a : α) (b h₁ h₂) : ↑(Units.mk a b h₁ h₂) = a :=
   rfl
 #align units.coe_mk Units.val_mk
 #align add_units.coe_mk AddUnits.val_mk
+-/
 
 #print Units.ext /-
 @[ext, to_additive]
@@ -152,11 +153,13 @@ theorem ext_iff {a b : αˣ} : a = b ↔ (a : α) = b :=
 @[to_additive]
 instance [DecidableEq α] : DecidableEq αˣ := fun a b => decidable_of_iff' _ ext_iff
 
+#print Units.mk_val /-
 @[simp, to_additive]
 theorem mk_val (u : αˣ) (y h₁ h₂) : mk (u : α) y h₁ h₂ = u :=
   ext rfl
 #align units.mk_coe Units.mk_val
 #align add_units.mk_coe AddUnits.mk_val
+-/
 
 #print Units.copy /-
 /-- Copy a unit, adjusting definition equalities. -/
@@ -213,28 +216,36 @@ instance [Repr α] : Repr αˣ :=
 
 variable (a b c : αˣ) {u : αˣ}
 
+#print Units.val_mul /-
 @[simp, norm_cast, to_additive]
 theorem val_mul : (↑(a * b) : α) = a * b :=
   rfl
 #align units.coe_mul Units.val_mul
 #align add_units.coe_add AddUnits.val_add
+-/
 
+#print Units.val_one /-
 @[simp, norm_cast, to_additive]
 theorem val_one : ((1 : αˣ) : α) = 1 :=
   rfl
 #align units.coe_one Units.val_one
 #align add_units.coe_zero AddUnits.val_zero
+-/
 
+#print Units.val_eq_one /-
 @[simp, norm_cast, to_additive]
 theorem val_eq_one {a : αˣ} : (a : α) = 1 ↔ a = 1 := by rw [← Units.val_one, eq_iff]
 #align units.coe_eq_one Units.val_eq_one
 #align add_units.coe_eq_zero AddUnits.val_eq_zero
+-/
 
+#print Units.inv_mk /-
 @[simp, to_additive]
 theorem inv_mk (x y : α) (h₁ h₂) : (mk x y h₁ h₂)⁻¹ = mk y x h₂ h₁ :=
   rfl
 #align units.inv_mk Units.inv_mk
 #align add_units.neg_mk AddUnits.neg_mk
+-/
 
 @[simp, to_additive]
 theorem val_eq_coe : a.val = (↑a : α) :=
@@ -250,89 +261,118 @@ theorem inv_eq_val_inv : a.inv = ((a⁻¹ : αˣ) : α) :=
 #align add_units.neg_eq_coe_neg AddUnits.neg_eq_val_neg
 -/
 
+#print Units.inv_mul /-
 @[simp, to_additive]
 theorem inv_mul : (↑a⁻¹ * a : α) = 1 :=
   inv_val _
 #align units.inv_mul Units.inv_mul
 #align add_units.neg_add AddUnits.neg_add
+-/
 
+#print Units.mul_inv /-
 @[simp, to_additive]
 theorem mul_inv : (a * ↑a⁻¹ : α) = 1 :=
   val_inv _
 #align units.mul_inv Units.mul_inv
 #align add_units.add_neg AddUnits.add_neg
+-/
 
+#print Units.inv_mul_of_eq /-
 @[to_additive]
 theorem inv_mul_of_eq {a : α} (h : ↑u = a) : ↑u⁻¹ * a = 1 := by rw [← h, u.inv_mul]
 #align units.inv_mul_of_eq Units.inv_mul_of_eq
 #align add_units.neg_add_of_eq AddUnits.neg_add_of_eq
+-/
 
+#print Units.mul_inv_of_eq /-
 @[to_additive]
 theorem mul_inv_of_eq {a : α} (h : ↑u = a) : a * ↑u⁻¹ = 1 := by rw [← h, u.mul_inv]
 #align units.mul_inv_of_eq Units.mul_inv_of_eq
 #align add_units.add_neg_of_eq AddUnits.add_neg_of_eq
+-/
 
+#print Units.mul_inv_cancel_left /-
 @[simp, to_additive]
 theorem mul_inv_cancel_left (a : αˣ) (b : α) : (a : α) * (↑a⁻¹ * b) = b := by
   rw [← mul_assoc, mul_inv, one_mul]
 #align units.mul_inv_cancel_left Units.mul_inv_cancel_left
 #align add_units.add_neg_cancel_left AddUnits.add_neg_cancel_left
+-/
 
+#print Units.inv_mul_cancel_left /-
 @[simp, to_additive]
 theorem inv_mul_cancel_left (a : αˣ) (b : α) : (↑a⁻¹ : α) * (a * b) = b := by
   rw [← mul_assoc, inv_mul, one_mul]
 #align units.inv_mul_cancel_left Units.inv_mul_cancel_left
 #align add_units.neg_add_cancel_left AddUnits.neg_add_cancel_left
+-/
 
+#print Units.mul_inv_cancel_right /-
 @[simp, to_additive]
 theorem mul_inv_cancel_right (a : α) (b : αˣ) : a * b * ↑b⁻¹ = a := by
   rw [mul_assoc, mul_inv, mul_one]
 #align units.mul_inv_cancel_right Units.mul_inv_cancel_right
 #align add_units.add_neg_cancel_right AddUnits.add_neg_cancel_right
+-/
 
+#print Units.inv_mul_cancel_right /-
 @[simp, to_additive]
 theorem inv_mul_cancel_right (a : α) (b : αˣ) : a * ↑b⁻¹ * b = a := by
   rw [mul_assoc, inv_mul, mul_one]
 #align units.inv_mul_cancel_right Units.inv_mul_cancel_right
 #align add_units.neg_add_cancel_right AddUnits.neg_add_cancel_right
+-/
 
+#print Units.mul_right_inj /-
 @[simp, to_additive]
 theorem mul_right_inj (a : αˣ) {b c : α} : (a : α) * b = a * c ↔ b = c :=
   ⟨fun h => by simpa only [inv_mul_cancel_left] using congr_arg ((· * ·) ↑(a⁻¹ : αˣ)) h,
     congr_arg _⟩
 #align units.mul_right_inj Units.mul_right_inj
 #align add_units.add_right_inj AddUnits.add_right_inj
+-/
 
+#print Units.mul_left_inj /-
 @[simp, to_additive]
 theorem mul_left_inj (a : αˣ) {b c : α} : b * a = c * a ↔ b = c :=
   ⟨fun h => by simpa only [mul_inv_cancel_right] using congr_arg (· * ↑(a⁻¹ : αˣ)) h, congr_arg _⟩
 #align units.mul_left_inj Units.mul_left_inj
 #align add_units.add_left_inj AddUnits.add_left_inj
+-/
 
+#print Units.eq_mul_inv_iff_mul_eq /-
 @[to_additive]
 theorem eq_mul_inv_iff_mul_eq {a b : α} : a = b * ↑c⁻¹ ↔ a * c = b :=
   ⟨fun h => by rw [h, inv_mul_cancel_right], fun h => by rw [← h, mul_inv_cancel_right]⟩
 #align units.eq_mul_inv_iff_mul_eq Units.eq_mul_inv_iff_mul_eq
 #align add_units.eq_add_neg_iff_add_eq AddUnits.eq_add_neg_iff_add_eq
+-/
 
+#print Units.eq_inv_mul_iff_mul_eq /-
 @[to_additive]
 theorem eq_inv_mul_iff_mul_eq {a c : α} : a = ↑b⁻¹ * c ↔ ↑b * a = c :=
   ⟨fun h => by rw [h, mul_inv_cancel_left], fun h => by rw [← h, inv_mul_cancel_left]⟩
 #align units.eq_inv_mul_iff_mul_eq Units.eq_inv_mul_iff_mul_eq
 #align add_units.eq_neg_add_iff_add_eq AddUnits.eq_neg_add_iff_add_eq
+-/
 
+#print Units.inv_mul_eq_iff_eq_mul /-
 @[to_additive]
 theorem inv_mul_eq_iff_eq_mul {b c : α} : ↑a⁻¹ * b = c ↔ b = a * c :=
   ⟨fun h => by rw [← h, mul_inv_cancel_left], fun h => by rw [h, inv_mul_cancel_left]⟩
 #align units.inv_mul_eq_iff_eq_mul Units.inv_mul_eq_iff_eq_mul
 #align add_units.neg_add_eq_iff_eq_add AddUnits.neg_add_eq_iff_eq_add
+-/
 
+#print Units.mul_inv_eq_iff_eq_mul /-
 @[to_additive]
 theorem mul_inv_eq_iff_eq_mul {a c : α} : a * ↑b⁻¹ = c ↔ a = c * b :=
   ⟨fun h => by rw [← h, inv_mul_cancel_right], fun h => by rw [h, mul_inv_cancel_right]⟩
 #align units.mul_inv_eq_iff_eq_mul Units.mul_inv_eq_iff_eq_mul
 #align add_units.add_neg_eq_iff_eq_add AddUnits.add_neg_eq_iff_eq_add
+-/
 
+#print Units.inv_eq_of_mul_eq_one_left /-
 @[to_additive]
 protected theorem inv_eq_of_mul_eq_one_left {a : α} (h : a * u = 1) : ↑u⁻¹ = a :=
   calc
@@ -340,7 +380,9 @@ protected theorem inv_eq_of_mul_eq_one_left {a : α} (h : a * u = 1) : ↑u⁻¹
     _ = a := by rw [← h, mul_inv_cancel_right]
 #align units.inv_eq_of_mul_eq_one_left Units.inv_eq_of_mul_eq_one_left
 #align add_units.neg_eq_of_add_eq_zero_left AddUnits.neg_eq_of_add_eq_zero_left
+-/
 
+#print Units.inv_eq_of_mul_eq_one_right /-
 @[to_additive]
 protected theorem inv_eq_of_mul_eq_one_right {a : α} (h : ↑u * a = 1) : ↑u⁻¹ = a :=
   calc
@@ -348,40 +390,53 @@ protected theorem inv_eq_of_mul_eq_one_right {a : α} (h : ↑u * a = 1) : ↑u
     _ = a := by rw [← h, inv_mul_cancel_left]
 #align units.inv_eq_of_mul_eq_one_right Units.inv_eq_of_mul_eq_one_right
 #align add_units.neg_eq_of_add_eq_zero_right AddUnits.neg_eq_of_add_eq_zero_right
+-/
 
+#print Units.eq_inv_of_mul_eq_one_left /-
 @[to_additive]
 protected theorem eq_inv_of_mul_eq_one_left {a : α} (h : ↑u * a = 1) : a = ↑u⁻¹ :=
   (Units.inv_eq_of_mul_eq_one_right h).symm
 #align units.eq_inv_of_mul_eq_one_left Units.eq_inv_of_mul_eq_one_left
 #align add_units.eq_neg_of_add_eq_zero_left AddUnits.eq_neg_of_add_eq_zero_left
+-/
 
+#print Units.eq_inv_of_mul_eq_one_right /-
 @[to_additive]
 protected theorem eq_inv_of_mul_eq_one_right {a : α} (h : a * u = 1) : a = ↑u⁻¹ :=
   (Units.inv_eq_of_mul_eq_one_left h).symm
 #align units.eq_inv_of_mul_eq_one_right Units.eq_inv_of_mul_eq_one_right
 #align add_units.eq_neg_of_add_eq_zero_right AddUnits.eq_neg_of_add_eq_zero_right
+-/
 
+#print Units.mul_inv_eq_one /-
 @[simp, to_additive]
 theorem mul_inv_eq_one {a : α} : a * ↑u⁻¹ = 1 ↔ a = u :=
   ⟨inv_inv u ▸ Units.eq_inv_of_mul_eq_one_right, fun h => mul_inv_of_eq h.symm⟩
 #align units.mul_inv_eq_one Units.mul_inv_eq_one
 #align add_units.add_neg_eq_zero AddUnits.add_neg_eq_zero
+-/
 
+#print Units.inv_mul_eq_one /-
 @[simp, to_additive]
 theorem inv_mul_eq_one {a : α} : ↑u⁻¹ * a = 1 ↔ ↑u = a :=
   ⟨inv_inv u ▸ Units.inv_eq_of_mul_eq_one_right, inv_mul_of_eq⟩
 #align units.inv_mul_eq_one Units.inv_mul_eq_one
 #align add_units.neg_add_eq_zero AddUnits.neg_add_eq_zero
+-/
 
+#print Units.mul_eq_one_iff_eq_inv /-
 @[to_additive]
 theorem mul_eq_one_iff_eq_inv {a : α} : a * u = 1 ↔ a = ↑u⁻¹ := by rw [← mul_inv_eq_one, inv_inv]
 #align units.mul_eq_one_iff_eq_inv Units.mul_eq_one_iff_eq_inv
 #align add_units.add_eq_zero_iff_eq_neg AddUnits.add_eq_zero_iff_eq_neg
+-/
 
+#print Units.mul_eq_one_iff_inv_eq /-
 @[to_additive]
 theorem mul_eq_one_iff_inv_eq {a : α} : ↑u * a = 1 ↔ ↑u⁻¹ = a := by rw [← inv_mul_eq_one, inv_inv]
 #align units.mul_eq_one_iff_inv_eq Units.mul_eq_one_iff_inv_eq
 #align add_units.add_eq_zero_iff_neg_eq AddUnits.add_eq_zero_iff_neg_eq
+-/
 
 #print Units.inv_unique /-
 @[to_additive]
@@ -391,14 +446,17 @@ theorem inv_unique {u₁ u₂ : αˣ} (h : (↑u₁ : α) = ↑u₂) : (↑u₁
 #align add_units.neg_unique AddUnits.neg_unique
 -/
 
+#print Units.val_inv_eq_inv_val /-
 @[simp, to_additive]
 theorem val_inv_eq_inv_val {M : Type _} [DivisionMonoid M] (u : Units M) : ↑u⁻¹ = (u⁻¹ : M) :=
   Eq.symm <| inv_eq_of_mul_eq_one_right u.mul_inv
 #align units.coe_inv Units.val_inv_eq_inv_val
 #align add_units.coe_sub AddUnits.val_neg_eq_neg_val
+-/
 
 end Units
 
+#print Units.mkOfMulEqOne /-
 /-- For `a, b` in a `comm_monoid` such that `a * b = 1`, makes a unit out of `a`. -/
 @[to_additive
       "For `a, b` in an `add_comm_monoid` such that `a + b = 0`, makes an add_unit\nout of `a`."]
@@ -406,13 +464,16 @@ def Units.mkOfMulEqOne [CommMonoid α] (a b : α) (hab : a * b = 1) : αˣ :=
   ⟨a, b, hab, (mul_comm b a).trans hab⟩
 #align units.mk_of_mul_eq_one Units.mkOfMulEqOne
 #align add_units.mk_of_add_eq_zero AddUnits.mkOfAddEqZero
+-/
 
+#print Units.val_mkOfMulEqOne /-
 @[simp, to_additive]
 theorem Units.val_mkOfMulEqOne [CommMonoid α] {a b : α} (h : a * b = 1) :
     (Units.mkOfMulEqOne a b h : α) = a :=
   rfl
 #align units.coe_mk_of_mul_eq_one Units.val_mkOfMulEqOne
 #align add_units.coe_mk_of_add_eq_zero AddUnits.val_mkOfAddEqZero
+-/
 
 section Monoid
 
@@ -427,43 +488,56 @@ def divp (a : α) (u) : α :=
 #align divp divp
 -/
 
--- mathport name: «expr /ₚ »
 infixl:70 " /ₚ " => divp
 
+#print divp_self /-
 @[simp]
 theorem divp_self (u : αˣ) : (u : α) /ₚ u = 1 :=
   Units.mul_inv _
 #align divp_self divp_self
+-/
 
+#print divp_one /-
 @[simp]
 theorem divp_one (a : α) : a /ₚ 1 = a :=
   mul_one _
 #align divp_one divp_one
+-/
 
+#print divp_assoc /-
 theorem divp_assoc (a b : α) (u : αˣ) : a * b /ₚ u = a * (b /ₚ u) :=
   mul_assoc _ _ _
 #align divp_assoc divp_assoc
+-/
 
+#print divp_assoc' /-
 /-- `field_simp` needs the reverse direction of `divp_assoc` to move all `/ₚ` to the right. -/
 @[field_simps]
 theorem divp_assoc' (x y : α) (u : αˣ) : x * (y /ₚ u) = x * y /ₚ u :=
   (divp_assoc _ _ _).symm
 #align divp_assoc' divp_assoc'
+-/
 
+#print divp_inv /-
 @[simp]
 theorem divp_inv (u : αˣ) : a /ₚ u⁻¹ = a * u :=
   rfl
 #align divp_inv divp_inv
+-/
 
+#print divp_mul_cancel /-
 @[simp]
 theorem divp_mul_cancel (a : α) (u : αˣ) : a /ₚ u * u = a :=
   (mul_assoc _ _ _).trans <| by rw [Units.inv_mul, mul_one]
 #align divp_mul_cancel divp_mul_cancel
+-/
 
+#print mul_divp_cancel /-
 @[simp]
 theorem mul_divp_cancel (a : α) (u : αˣ) : a * u /ₚ u = a :=
   (mul_assoc _ _ _).trans <| by rw [Units.mul_inv, mul_one]
 #align mul_divp_cancel mul_divp_cancel
+-/
 
 #print divp_left_inj /-
 @[simp]
@@ -472,35 +546,48 @@ theorem divp_left_inj (u : αˣ) {a b : α} : a /ₚ u = b /ₚ u ↔ a = b :=
 #align divp_left_inj divp_left_inj
 -/
 
+#print divp_divp_eq_divp_mul /-
 @[field_simps]
 theorem divp_divp_eq_divp_mul (x : α) (u₁ u₂ : αˣ) : x /ₚ u₁ /ₚ u₂ = x /ₚ (u₂ * u₁) := by
   simp only [divp, mul_inv_rev, Units.val_mul, mul_assoc]
 #align divp_divp_eq_divp_mul divp_divp_eq_divp_mul
+-/
 
+#print divp_eq_iff_mul_eq /-
 @[field_simps]
 theorem divp_eq_iff_mul_eq {x : α} {u : αˣ} {y : α} : x /ₚ u = y ↔ y * u = x :=
   u.mul_left_inj.symm.trans <| by rw [divp_mul_cancel] <;> exact ⟨Eq.symm, Eq.symm⟩
 #align divp_eq_iff_mul_eq divp_eq_iff_mul_eq
+-/
 
+#print eq_divp_iff_mul_eq /-
 @[field_simps]
 theorem eq_divp_iff_mul_eq {x : α} {u : αˣ} {y : α} : x = y /ₚ u ↔ x * u = y := by
   rw [eq_comm, divp_eq_iff_mul_eq]
 #align eq_divp_iff_mul_eq eq_divp_iff_mul_eq
+-/
 
+#print divp_eq_one_iff_eq /-
 theorem divp_eq_one_iff_eq {a : α} {u : αˣ} : a /ₚ u = 1 ↔ a = u :=
   (Units.mul_left_inj u).symm.trans <| by rw [divp_mul_cancel, one_mul]
 #align divp_eq_one_iff_eq divp_eq_one_iff_eq
+-/
 
+#print one_divp /-
 @[simp]
 theorem one_divp (u : αˣ) : 1 /ₚ u = ↑u⁻¹ :=
   one_mul _
 #align one_divp one_divp
+-/
 
+#print inv_eq_one_divp /-
 /-- Used for `field_simp` to deal with inverses of units. -/
 @[field_simps]
 theorem inv_eq_one_divp (u : αˣ) : ↑u⁻¹ = 1 /ₚ u := by rw [one_divp]
 #align inv_eq_one_divp inv_eq_one_divp
+-/
 
+#print inv_eq_one_divp' /-
 /-- Used for `field_simp` to deal with inverses of units. This form of the lemma
 is essential since `field_simp` likes to use `inv_eq_one_div` to rewrite
 `↑u⁻¹ = ↑(1 / u)`.
@@ -508,7 +595,9 @@ is essential since `field_simp` likes to use `inv_eq_one_div` to rewrite
 @[field_simps]
 theorem inv_eq_one_divp' (u : αˣ) : ((1 / u : αˣ) : α) = 1 /ₚ u := by rw [one_div, one_divp]
 #align inv_eq_one_divp' inv_eq_one_divp'
+-/
 
+#print val_div_eq_divp /-
 /-- `field_simp` moves division inside `αˣ` to the right, and this lemma
 lifts the calculation to `α`.
 -/
@@ -516,6 +605,7 @@ lifts the calculation to `α`.
 theorem val_div_eq_divp (u₁ u₂ : αˣ) : ↑(u₁ / u₂) = ↑u₁ /ₚ u₂ := by
   rw [divp, division_def, Units.val_mul]
 #align coe_div_eq_divp val_div_eq_divp
+-/
 
 end Monoid
 
@@ -523,42 +613,54 @@ section CommMonoid
 
 variable [CommMonoid α]
 
+#print divp_mul_eq_mul_divp /-
 @[field_simps]
 theorem divp_mul_eq_mul_divp (x y : α) (u : αˣ) : x /ₚ u * y = x * y /ₚ u := by
   simp_rw [divp, mul_assoc, mul_comm]
 #align divp_mul_eq_mul_divp divp_mul_eq_mul_divp
+-/
 
+#print divp_eq_divp_iff /-
 -- Theoretically redundant as `field_simp` lemma.
 @[field_simps]
 theorem divp_eq_divp_iff {x y : α} {ux uy : αˣ} : x /ₚ ux = y /ₚ uy ↔ x * uy = y * ux := by
   rw [divp_eq_iff_mul_eq, divp_mul_eq_mul_divp, divp_eq_iff_mul_eq]
 #align divp_eq_divp_iff divp_eq_divp_iff
+-/
 
+#print divp_mul_divp /-
 -- Theoretically redundant as `field_simp` lemma.
 @[field_simps]
 theorem divp_mul_divp (x y : α) (ux uy : αˣ) : x /ₚ ux * (y /ₚ uy) = x * y /ₚ (ux * uy) := by
   rw [divp_mul_eq_mul_divp, divp_assoc', divp_divp_eq_divp_mul]
 #align divp_mul_divp divp_mul_divp
+-/
 
 variable [Subsingleton αˣ] {a b : α}
 
+#print eq_one_of_mul_right /-
 @[to_additive]
 theorem eq_one_of_mul_right (h : a * b = 1) : a = 1 :=
   congr_arg Units.inv <| Subsingleton.elim (Units.mk _ _ (by rwa [mul_comm]) h) 1
 #align eq_one_of_mul_right eq_one_of_mul_right
 #align eq_zero_of_add_right eq_zero_of_add_right
+-/
 
+#print eq_one_of_mul_left /-
 @[to_additive]
 theorem eq_one_of_mul_left (h : a * b = 1) : b = 1 :=
   congr_arg Units.inv <| Subsingleton.elim (Units.mk _ _ h <| by rwa [mul_comm]) 1
 #align eq_one_of_mul_left eq_one_of_mul_left
 #align eq_zero_of_add_left eq_zero_of_add_left
+-/
 
+#print mul_eq_one /-
 @[simp, to_additive]
 theorem mul_eq_one : a * b = 1 ↔ a = 1 ∧ b = 1 :=
   ⟨fun h => ⟨eq_one_of_mul_right h, eq_one_of_mul_left h⟩, by rintro ⟨rfl, rfl⟩; exact mul_one _⟩
 #align mul_eq_one mul_eq_one
 #align add_eq_zero add_eq_zero
+-/
 
 end CommMonoid
 
@@ -615,48 +717,63 @@ protected theorem Units.isUnit [Monoid M] (u : Mˣ) : IsUnit (u : M) :=
 #align add_units.is_add_unit_add_unit AddUnits.isAddUnit
 -/
 
+#print isUnit_one /-
 @[simp, to_additive]
 theorem isUnit_one [Monoid M] : IsUnit (1 : M) :=
   ⟨1, rfl⟩
 #align is_unit_one isUnit_one
 #align is_add_unit_zero isAddUnit_zero
+-/
 
+#print isUnit_of_mul_eq_one /-
 @[to_additive]
 theorem isUnit_of_mul_eq_one [CommMonoid M] (a b : M) (h : a * b = 1) : IsUnit a :=
   ⟨Units.mkOfMulEqOne a b h, rfl⟩
 #align is_unit_of_mul_eq_one isUnit_of_mul_eq_one
 #align is_add_unit_of_add_eq_zero isAddUnit_of_add_eq_zero
+-/
 
+#print IsUnit.exists_right_inv /-
 @[to_additive IsAddUnit.exists_neg]
 theorem IsUnit.exists_right_inv [Monoid M] {a : M} (h : IsUnit a) : ∃ b, a * b = 1 := by
   rcases h with ⟨⟨a, b, hab, _⟩, rfl⟩; exact ⟨b, hab⟩
 #align is_unit.exists_right_inv IsUnit.exists_right_inv
 #align is_add_unit.exists_neg IsAddUnit.exists_neg
+-/
 
+#print IsUnit.exists_left_inv /-
 @[to_additive IsAddUnit.exists_neg']
 theorem IsUnit.exists_left_inv [Monoid M] {a : M} (h : IsUnit a) : ∃ b, b * a = 1 := by
   rcases h with ⟨⟨a, b, _, hba⟩, rfl⟩; exact ⟨b, hba⟩
 #align is_unit.exists_left_inv IsUnit.exists_left_inv
 #align is_add_unit.exists_neg' IsAddUnit.exists_neg'
+-/
 
+#print isUnit_iff_exists_inv /-
 @[to_additive]
 theorem isUnit_iff_exists_inv [CommMonoid M] {a : M} : IsUnit a ↔ ∃ b, a * b = 1 :=
   ⟨fun h => h.exists_right_inv, fun ⟨b, hab⟩ => isUnit_of_mul_eq_one _ b hab⟩
 #align is_unit_iff_exists_inv isUnit_iff_exists_inv
 #align is_add_unit_iff_exists_neg isAddUnit_iff_exists_neg
+-/
 
+#print isUnit_iff_exists_inv' /-
 @[to_additive]
 theorem isUnit_iff_exists_inv' [CommMonoid M] {a : M} : IsUnit a ↔ ∃ b, b * a = 1 := by
   simp [isUnit_iff_exists_inv, mul_comm]
 #align is_unit_iff_exists_inv' isUnit_iff_exists_inv'
 #align is_add_unit_iff_exists_neg' isAddUnit_iff_exists_neg'
+-/
 
+#print IsUnit.mul /-
 @[to_additive]
 theorem IsUnit.mul [Monoid M] {x y : M} : IsUnit x → IsUnit y → IsUnit (x * y) := by
   rintro ⟨x, rfl⟩ ⟨y, rfl⟩; exact ⟨x * y, Units.val_mul _ _⟩
 #align is_unit.mul IsUnit.mul
 #align is_add_unit.add IsAddUnit.add
+-/
 
+#print Units.isUnit_mul_units /-
 /-- Multiplication by a `u : Mˣ` on the right doesn't affect `is_unit`. -/
 @[simp, to_additive "Addition of a `u : add_units M` on the right doesn't\naffect `is_add_unit`."]
 theorem Units.isUnit_mul_units [Monoid M] (a : M) (u : Mˣ) : IsUnit (a * u) ↔ IsUnit a :=
@@ -668,7 +785,9 @@ theorem Units.isUnit_mul_units [Monoid M] (a : M) (u : Mˣ) : IsUnit (a * u) ↔
     fun v => v.mul u.IsUnit
 #align units.is_unit_mul_units Units.isUnit_mul_units
 #align add_units.is_add_unit_add_add_units AddUnits.isAddUnit_add_addUnits
+-/
 
+#print Units.isUnit_units_mul /-
 /-- Multiplication by a `u : Mˣ` on the left doesn't affect `is_unit`. -/
 @[simp, to_additive "Addition of a `u : add_units M` on the left doesn't affect `is_add_unit`."]
 theorem Units.isUnit_units_mul {M : Type _} [Monoid M] (u : Mˣ) (a : M) :
@@ -681,28 +800,35 @@ theorem Units.isUnit_units_mul {M : Type _} [Monoid M] (u : Mˣ) (a : M) :
     u.IsUnit.mul
 #align units.is_unit_units_mul Units.isUnit_units_mul
 #align add_units.is_add_unit_add_units_add AddUnits.isAddUnit_addUnits_add
+-/
 
+#print isUnit_of_mul_isUnit_left /-
 @[to_additive]
 theorem isUnit_of_mul_isUnit_left [CommMonoid M] {x y : M} (hu : IsUnit (x * y)) : IsUnit x :=
   let ⟨z, hz⟩ := isUnit_iff_exists_inv.1 hu
   isUnit_iff_exists_inv.2 ⟨y * z, by rwa [← mul_assoc]⟩
 #align is_unit_of_mul_is_unit_left isUnit_of_mul_isUnit_left
 #align is_add_unit_of_add_is_add_unit_left isAddUnit_of_add_isAddUnit_left
+-/
 
+#print isUnit_of_mul_isUnit_right /-
 @[to_additive]
 theorem isUnit_of_mul_isUnit_right [CommMonoid M] {x y : M} (hu : IsUnit (x * y)) : IsUnit y :=
   @isUnit_of_mul_isUnit_left _ _ y x <| by rwa [mul_comm]
 #align is_unit_of_mul_is_unit_right isUnit_of_mul_isUnit_right
 #align is_add_unit_of_add_is_add_unit_right isAddUnit_of_add_isAddUnit_right
+-/
 
 namespace IsUnit
 
+#print IsUnit.mul_iff /-
 @[simp, to_additive]
 theorem mul_iff [CommMonoid M] {x y : M} : IsUnit (x * y) ↔ IsUnit x ∧ IsUnit y :=
   ⟨fun h => ⟨isUnit_of_mul_isUnit_left h, isUnit_of_mul_isUnit_right h⟩, fun h =>
     IsUnit.mul h.1 h.2⟩
 #align is_unit.mul_iff IsUnit.mul_iff
 #align is_add_unit.add_iff IsAddUnit.add_iff
+-/
 
 section Monoid
 
@@ -735,75 +861,95 @@ theorem unit_spec (h : IsUnit a) : ↑h.Unit = a :=
 #align is_add_unit.add_unit_spec IsAddUnit.addUnit_spec
 -/
 
+#print IsUnit.val_inv_mul /-
 @[simp, to_additive]
 theorem val_inv_mul (h : IsUnit a) : ↑h.Unit⁻¹ * a = 1 :=
   Units.mul_inv _
 #align is_unit.coe_inv_mul IsUnit.val_inv_mul
 #align is_add_unit.coe_neg_add IsAddUnit.val_neg_add
+-/
 
+#print IsUnit.mul_val_inv /-
 @[simp, to_additive]
 theorem mul_val_inv (h : IsUnit a) : a * ↑h.Unit⁻¹ = 1 := by convert h.unit.mul_inv
 #align is_unit.mul_coe_inv IsUnit.mul_val_inv
 #align is_add_unit.add_coe_neg IsAddUnit.add_val_neg
+-/
 
 /-- `is_unit x` is decidable if we can decide if `x` comes from `Mˣ`. -/
 @[to_additive "`is_add_unit x` is decidable if we can decide if `x` comes from `add_units M"]
 instance (x : M) [h : Decidable (∃ u : Mˣ, ↑u = x)] : Decidable (IsUnit x) :=
   h
 
+#print IsUnit.mul_left_inj /-
 @[to_additive]
 theorem mul_left_inj (h : IsUnit a) : b * a = c * a ↔ b = c :=
   let ⟨u, hu⟩ := h
   hu ▸ u.mul_left_inj
 #align is_unit.mul_left_inj IsUnit.mul_left_inj
 #align is_add_unit.add_left_inj IsAddUnit.add_left_inj
+-/
 
+#print IsUnit.mul_right_inj /-
 @[to_additive]
 theorem mul_right_inj (h : IsUnit a) : a * b = a * c ↔ b = c :=
   let ⟨u, hu⟩ := h
   hu ▸ u.mul_right_inj
 #align is_unit.mul_right_inj IsUnit.mul_right_inj
 #align is_add_unit.add_right_inj IsAddUnit.add_right_inj
+-/
 
+#print IsUnit.mul_left_cancel /-
 @[to_additive]
 protected theorem mul_left_cancel (h : IsUnit a) : a * b = a * c → b = c :=
   h.mul_right_inj.1
 #align is_unit.mul_left_cancel IsUnit.mul_left_cancel
 #align is_add_unit.add_left_cancel IsAddUnit.add_left_cancel
+-/
 
+#print IsUnit.mul_right_cancel /-
 @[to_additive]
 protected theorem mul_right_cancel (h : IsUnit b) : a * b = c * b → a = c :=
   h.mul_left_inj.1
 #align is_unit.mul_right_cancel IsUnit.mul_right_cancel
 #align is_add_unit.add_right_cancel IsAddUnit.add_right_cancel
+-/
 
+#print IsUnit.mul_right_injective /-
 @[to_additive]
 protected theorem mul_right_injective (h : IsUnit a) : Injective ((· * ·) a) := fun _ _ =>
   h.mul_left_cancel
 #align is_unit.mul_right_injective IsUnit.mul_right_injective
 #align is_add_unit.add_right_injective IsAddUnit.add_right_injective
+-/
 
+#print IsUnit.mul_left_injective /-
 @[to_additive]
 protected theorem mul_left_injective (h : IsUnit b) : Injective (· * b) := fun _ _ =>
   h.mul_right_cancel
 #align is_unit.mul_left_injective IsUnit.mul_left_injective
 #align is_add_unit.add_left_injective IsAddUnit.add_left_injective
+-/
 
 end Monoid
 
 variable [DivisionMonoid M] {a : M}
 
+#print IsUnit.inv_mul_cancel /-
 @[simp, to_additive]
 protected theorem inv_mul_cancel : IsUnit a → a⁻¹ * a = 1 := by rintro ⟨u, rfl⟩;
   rw [← Units.val_inv_eq_inv_val, Units.inv_mul]
 #align is_unit.inv_mul_cancel IsUnit.inv_mul_cancel
 #align is_add_unit.neg_add_cancel IsAddUnit.neg_add_cancel
+-/
 
+#print IsUnit.mul_inv_cancel /-
 @[simp, to_additive]
 protected theorem mul_inv_cancel : IsUnit a → a * a⁻¹ = 1 := by rintro ⟨u, rfl⟩;
   rw [← Units.val_inv_eq_inv_val, Units.mul_inv]
 #align is_unit.mul_inv_cancel IsUnit.mul_inv_cancel
 #align is_add_unit.add_neg_cancel IsAddUnit.add_neg_cancel
+-/
 
 end IsUnit

bump to nightly-2023-06-09-07

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

16afdc39

Diff

@@ -338,7 +338,6 @@ protected theorem inv_eq_of_mul_eq_one_left {a : α} (h : a * u = 1) : ↑u⁻¹
   calc
     ↑u⁻¹ = 1 * ↑u⁻¹ := by rw [one_mul]
     _ = a := by rw [← h, mul_inv_cancel_right]
-    
 #align units.inv_eq_of_mul_eq_one_left Units.inv_eq_of_mul_eq_one_left
 #align add_units.neg_eq_of_add_eq_zero_left AddUnits.neg_eq_of_add_eq_zero_left
 
@@ -347,7 +346,6 @@ protected theorem inv_eq_of_mul_eq_one_right {a : α} (h : ↑u * a = 1) : ↑u
   calc
     ↑u⁻¹ = ↑u⁻¹ * 1 := by rw [mul_one]
     _ = a := by rw [← h, inv_mul_cancel_left]
-    
 #align units.inv_eq_of_mul_eq_one_right Units.inv_eq_of_mul_eq_one_right
 #align add_units.neg_eq_of_add_eq_zero_right AddUnits.neg_eq_of_add_eq_zero_right

bump to nightly-2023-06-01-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

b9c87c70

Diff

@@ -127,7 +127,7 @@ theorem val_mk (a : α) (b h₁ h₂) : ↑(Units.mk a b h₁ h₂) = a :=
 @[ext, to_additive]
 theorem ext : Function.Injective (coe : αˣ → α)
   | ⟨v, i₁, vi₁, iv₁⟩, ⟨v', i₂, vi₂, iv₂⟩, e => by
-    change v = v' at e <;> subst v' <;> congr <;>
+    change v = v' at e  <;> subst v' <;> congr <;>
       simpa only [iv₂, vi₁, one_mul, mul_one] using mul_assoc i₂ v i₁
 #align units.ext Units.ext
 #align add_units.ext AddUnits.ext
@@ -666,7 +666,7 @@ theorem Units.isUnit_mul_units [Monoid M] (a : M) (u : Mˣ) : IsUnit (a * u) ↔
     (fun ⟨v, hv⟩ =>
       by
       have : IsUnit (a * ↑u * ↑u⁻¹) := by exists v * u⁻¹ <;> rw [← hv, Units.val_mul]
-      rwa [mul_assoc, Units.mul_inv, mul_one] at this)
+      rwa [mul_assoc, Units.mul_inv, mul_one] at this )
     fun v => v.mul u.IsUnit
 #align units.is_unit_mul_units Units.isUnit_mul_units
 #align add_units.is_add_unit_add_add_units AddUnits.isAddUnit_add_addUnits
@@ -679,7 +679,7 @@ theorem Units.isUnit_units_mul {M : Type _} [Monoid M] (u : Mˣ) (a : M) :
     (fun ⟨v, hv⟩ =>
       by
       have : IsUnit (↑u⁻¹ * (↑u * a)) := by exists u⁻¹ * v <;> rw [← hv, Units.val_mul]
-      rwa [← mul_assoc, Units.inv_mul, one_mul] at this)
+      rwa [← mul_assoc, Units.inv_mul, one_mul] at this )
     u.IsUnit.mul
 #align units.is_unit_units_mul Units.isUnit_units_mul
 #align add_units.is_add_unit_add_units_add AddUnits.isAddUnit_addUnits_add

bump to nightly-2023-06-01-04

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

4d9eaa85

Diff

@@ -99,25 +99,23 @@ instance : Coe αˣ α :=
 instance : Inv αˣ :=
   ⟨fun u => ⟨u.2, u.1, u.4, u.3⟩⟩
 
-/- warning: units.simps.coe clashes with [anonymous] -> [anonymous]
-Case conversion may be inaccurate. Consider using '#align units.simps.coe [anonymous]ₓ'. -/
 /-- See Note [custom simps projection] -/
 @[to_additive " See Note [custom simps projection] "]
-def [anonymous] (u : αˣ) : α :=
+def Simps.coe (u : αˣ) : α :=
   u
-#align units.simps.coe [anonymous]
+#align units.simps.coe Units.Simps.coe
+#align add_units.simps.coe AddUnits.Simps.coe
 
-/- warning: units.simps.coe_inv clashes with [anonymous] -> [anonymous]
-Case conversion may be inaccurate. Consider using '#align units.simps.coe_inv [anonymous]ₓ'. -/
 /-- See Note [custom simps projection] -/
 @[to_additive " See Note [custom simps projection] "]
-def [anonymous] (u : αˣ) : α :=
+def Simps.coeInv (u : αˣ) : α :=
   ↑u⁻¹
-#align units.simps.coe_inv [anonymous]
+#align units.simps.coe_inv Units.Simps.coeInv
+#align add_units.simps.coe_neg AddUnits.Simps.coeNeg
 
-initialize_simps_projections Units (val → coe, as_prefix coe, inv → coe_inv, as_prefix coe_inv)
+initialize_simps_projections Units (val → coe, as_prefix coe, inv → coeInv, as_prefix coeInv)
 
-initialize_simps_projections AddUnits (val → coe, as_prefix coe, neg → coe_neg, as_prefix coe_neg)
+initialize_simps_projections AddUnits (val → coe, as_prefix coe, neg → coeNeg, as_prefix coeNeg)
 
 @[simp, to_additive]
 theorem val_mk (a : α) (b h₁ h₂) : ↑(Units.mk a b h₁ h₂) = a :=
@@ -238,12 +236,11 @@ theorem inv_mk (x y : α) (h₁ h₂) : (mk x y h₁ h₂)⁻¹ = mk y x h₂ h
 #align units.inv_mk Units.inv_mk
 #align add_units.neg_mk AddUnits.neg_mk
 
-/- warning: units.val_eq_coe clashes with [anonymous] -> [anonymous]
-Case conversion may be inaccurate. Consider using '#align units.val_eq_coe [anonymous]ₓ'. -/
 @[simp, to_additive]
-theorem [anonymous] : a.val = (↑a : α) :=
+theorem val_eq_coe : a.val = (↑a : α) :=
   rfl
-#align units.val_eq_coe [anonymous]
+#align units.val_eq_coe Units.val_eq_coe
+#align add_units.val_eq_coe AddUnits.val_eq_coe
 
 #print Units.inv_eq_val_inv /-
 @[simp, to_additive]

bump to nightly-2023-05-28-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

ba5d8b97

Diff

@@ -100,11 +100,6 @@ instance : Inv αˣ :=
   ⟨fun u => ⟨u.2, u.1, u.4, u.3⟩⟩
 
 /- warning: units.simps.coe clashes with [anonymous] -> [anonymous]
-warning: units.simps.coe -> [anonymous] is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u}} [_inst_1 : Monoid.{u} α], (Units.{u} α _inst_1) -> α
-but is expected to have type
-  forall {α : Type.{u}} {_inst_1 : Type.{v}}, (Nat -> α -> _inst_1) -> Nat -> (List.{u} α) -> (List.{v} _inst_1)
 Case conversion may be inaccurate. Consider using '#align units.simps.coe [anonymous]ₓ'. -/
 /-- See Note [custom simps projection] -/
 @[to_additive " See Note [custom simps projection] "]
@@ -113,11 +108,6 @@ def [anonymous] (u : αˣ) : α :=
 #align units.simps.coe [anonymous]
 
 /- warning: units.simps.coe_inv clashes with [anonymous] -> [anonymous]
-warning: units.simps.coe_inv -> [anonymous] is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u}} [_inst_1 : Monoid.{u} α], (Units.{u} α _inst_1) -> α
-but is expected to have type
-  forall {α : Type.{u}} {_inst_1 : Type.{v}}, (Nat -> α -> _inst_1) -> Nat -> (List.{u} α) -> (List.{v} _inst_1)
 Case conversion may be inaccurate. Consider using '#align units.simps.coe_inv [anonymous]ₓ'. -/
 /-- See Note [custom simps projection] -/
 @[to_additive " See Note [custom simps projection] "]
@@ -129,12 +119,6 @@ initialize_simps_projections Units (val → coe, as_prefix coe, inv → coe_inv,
 
 initialize_simps_projections AddUnits (val → coe, as_prefix coe, neg → coe_neg, as_prefix coe_neg)
 
-/- warning: units.coe_mk -> Units.val_mk is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) (h₁ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (h₂ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) b a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))), Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Units.mk.{u1} α _inst_1 a b h₁ h₂)) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) (h₁ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (h₂ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) b a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))), Eq.{succ u1} α (Units.val.{u1} α _inst_1 (Units.mk.{u1} α _inst_1 a b h₁ h₂)) a
-Case conversion may be inaccurate. Consider using '#align units.coe_mk Units.val_mkₓ'. -/
 @[simp, to_additive]
 theorem val_mk (a : α) (b h₁ h₂) : ↑(Units.mk a b h₁ h₂) = a :=
   rfl
@@ -170,12 +154,6 @@ theorem ext_iff {a b : αˣ} : a = b ↔ (a : α) = b :=
 @[to_additive]
 instance [DecidableEq α] : DecidableEq αˣ := fun a b => decidable_of_iff' _ ext_iff
 
-/- warning: units.mk_coe -> Units.mk_val is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1) (y : α) (h₁ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u) y) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (h₂ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))), Eq.{succ u1} (Units.{u1} α _inst_1) (Units.mk.{u1} α _inst_1 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u) y h₁ h₂) u
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1) (y : α) (h₁ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 u) y) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (h₂ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) y (Units.val.{u1} α _inst_1 u)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))), Eq.{succ u1} (Units.{u1} α _inst_1) (Units.mk.{u1} α _inst_1 (Units.val.{u1} α _inst_1 u) y h₁ h₂) u
-Case conversion may be inaccurate. Consider using '#align units.mk_coe Units.mk_valₓ'. -/
 @[simp, to_additive]
 theorem mk_val (u : αˣ) (y h₁ h₂) : mk (u : α) y h₁ h₂ = u :=
   ext rfl
@@ -237,47 +215,23 @@ instance [Repr α] : Repr αˣ :=
 
 variable (a b c : αˣ) {u : αˣ}
 
-/- warning: units.coe_mul -> Units.val_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) (b : Units.{u1} α _inst_1), Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} (Units.{u1} α _inst_1) (Units.{u1} α _inst_1) (Units.{u1} α _inst_1) (instHMul.{u1} (Units.{u1} α _inst_1) (MulOneClass.toHasMul.{u1} (Units.{u1} α _inst_1) (Units.mulOneClass.{u1} α _inst_1))) a b)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) a) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) (b : Units.{u1} α _inst_1), Eq.{succ u1} α (Units.val.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} (Units.{u1} α _inst_1) (Units.{u1} α _inst_1) (Units.{u1} α _inst_1) (instHMul.{u1} (Units.{u1} α _inst_1) (MulOneClass.toMul.{u1} (Units.{u1} α _inst_1) (Units.instMulOneClassUnits.{u1} α _inst_1))) a b)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 a) (Units.val.{u1} α _inst_1 b))
-Case conversion may be inaccurate. Consider using '#align units.coe_mul Units.val_mulₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem val_mul : (↑(a * b) : α) = a * b :=
   rfl
 #align units.coe_mul Units.val_mul
 #align add_units.coe_add AddUnits.val_add
 
-/- warning: units.coe_one -> Units.val_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (Units.{u1} α _inst_1) 1 (OfNat.mk.{u1} (Units.{u1} α _inst_1) 1 (One.one.{u1} (Units.{u1} α _inst_1) (MulOneClass.toHasOne.{u1} (Units.{u1} α _inst_1) (Units.mulOneClass.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} α (Units.val.{u1} α _inst_1 (OfNat.ofNat.{u1} (Units.{u1} α _inst_1) 1 (One.toOfNat1.{u1} (Units.{u1} α _inst_1) (InvOneClass.toOne.{u1} (Units.{u1} α _inst_1) (DivInvOneMonoid.toInvOneClass.{u1} (Units.{u1} α _inst_1) (DivisionMonoid.toDivInvOneMonoid.{u1} (Units.{u1} α _inst_1) (Group.toDivisionMonoid.{u1} (Units.{u1} α _inst_1) (Units.instGroupUnits.{u1} α _inst_1)))))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align units.coe_one Units.val_oneₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem val_one : ((1 : αˣ) : α) = 1 :=
   rfl
 #align units.coe_one Units.val_one
 #align add_units.coe_zero AddUnits.val_zero
 
-/- warning: units.coe_eq_one -> Units.val_eq_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : Units.{u1} α _inst_1}, Iff (Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (Eq.{succ u1} (Units.{u1} α _inst_1) a (OfNat.ofNat.{u1} (Units.{u1} α _inst_1) 1 (OfNat.mk.{u1} (Units.{u1} α _inst_1) 1 (One.one.{u1} (Units.{u1} α _inst_1) (MulOneClass.toHasOne.{u1} (Units.{u1} α _inst_1) (Units.mulOneClass.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : Units.{u1} α _inst_1}, Iff (Eq.{succ u1} α (Units.val.{u1} α _inst_1 a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (Eq.{succ u1} (Units.{u1} α _inst_1) a (OfNat.ofNat.{u1} (Units.{u1} α _inst_1) 1 (One.toOfNat1.{u1} (Units.{u1} α _inst_1) (InvOneClass.toOne.{u1} (Units.{u1} α _inst_1) (DivInvOneMonoid.toInvOneClass.{u1} (Units.{u1} α _inst_1) (DivisionMonoid.toDivInvOneMonoid.{u1} (Units.{u1} α _inst_1) (Group.toDivisionMonoid.{u1} (Units.{u1} α _inst_1) (Units.instGroupUnits.{u1} α _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align units.coe_eq_one Units.val_eq_oneₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem val_eq_one {a : αˣ} : (a : α) = 1 ↔ a = 1 := by rw [← Units.val_one, eq_iff]
 #align units.coe_eq_one Units.val_eq_one
 #align add_units.coe_eq_zero AddUnits.val_eq_zero
 
-/- warning: units.inv_mk -> Units.inv_mk is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (x : α) (y : α) (h₁ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) x y) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (h₂ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) y x) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))), Eq.{succ u1} (Units.{u1} α _inst_1) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) (Units.mk.{u1} α _inst_1 x y h₁ h₂)) (Units.mk.{u1} α _inst_1 y x h₂ h₁)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (x : α) (y : α) (h₁ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) x y) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (h₂ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) y x) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))), Eq.{succ u1} (Units.{u1} α _inst_1) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) (Units.mk.{u1} α _inst_1 x y h₁ h₂)) (Units.mk.{u1} α _inst_1 y x h₂ h₁)
-Case conversion may be inaccurate. Consider using '#align units.inv_mk Units.inv_mkₓ'. -/
 @[simp, to_additive]
 theorem inv_mk (x y : α) (h₁ h₂) : (mk x y h₁ h₂)⁻¹ = mk y x h₂ h₁ :=
   rfl
@@ -285,11 +239,6 @@ theorem inv_mk (x y : α) (h₁ h₂) : (mk x y h₁ h₂)⁻¹ = mk y x h₂ h
 #align add_units.neg_mk AddUnits.neg_mk
 
 /- warning: units.val_eq_coe clashes with [anonymous] -> [anonymous]
-warning: units.val_eq_coe -> [anonymous] is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u}} [_inst_1 : Monoid.{u} α] (a : Units.{u} α _inst_1), Eq.{succ u} α (Units.val.{u} α _inst_1 a) ((fun (a : Type.{u}) (b : Type.{u}) [self : HasLiftT.{succ u, succ u} a b] => self.0) (Units.{u} α _inst_1) α (HasLiftT.mk.{succ u, succ u} (Units.{u} α _inst_1) α (CoeTCₓ.coe.{succ u, succ u} (Units.{u} α _inst_1) α (coeBase.{succ u, succ u} (Units.{u} α _inst_1) α (Units.hasCoe.{u} α _inst_1)))) a)
-but is expected to have type
-  forall {α : Type.{u}} {_inst_1 : Type.{v}}, (Nat -> α -> _inst_1) -> Nat -> (List.{u} α) -> (List.{v} _inst_1)
 Case conversion may be inaccurate. Consider using '#align units.val_eq_coe [anonymous]ₓ'. -/
 @[simp, to_additive]
 theorem [anonymous] : a.val = (↑a : α) :=
@@ -304,106 +253,52 @@ theorem inv_eq_val_inv : a.inv = ((a⁻¹ : αˣ) : α) :=
 #align add_units.neg_eq_coe_neg AddUnits.neg_eq_val_neg
 -/
 
-/- warning: units.inv_mul -> Units.inv_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) a)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) a)) (Units.val.{u1} α _inst_1 a)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align units.inv_mul Units.inv_mulₓ'. -/
 @[simp, to_additive]
 theorem inv_mul : (↑a⁻¹ * a : α) = 1 :=
   inv_val _
 #align units.inv_mul Units.inv_mul
 #align add_units.neg_add AddUnits.neg_add
 
-/- warning: units.mul_inv -> Units.mul_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) a) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) a))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 a) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) a))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align units.mul_inv Units.mul_invₓ'. -/
 @[simp, to_additive]
 theorem mul_inv : (a * ↑a⁻¹ : α) = 1 :=
   val_inv _
 #align units.mul_inv Units.mul_inv
 #align add_units.add_neg AddUnits.add_neg
 
-/- warning: units.inv_mul_of_eq -> Units.inv_mul_of_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u) a) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (Units.val.{u1} α _inst_1 u) a) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align units.inv_mul_of_eq Units.inv_mul_of_eqₓ'. -/
 @[to_additive]
 theorem inv_mul_of_eq {a : α} (h : ↑u = a) : ↑u⁻¹ * a = 1 := by rw [← h, u.inv_mul]
 #align units.inv_mul_of_eq Units.inv_mul_of_eq
 #align add_units.neg_add_of_eq AddUnits.neg_add_of_eq
 
-/- warning: units.mul_inv_of_eq -> Units.mul_inv_of_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u) a) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (Units.val.{u1} α _inst_1 u) a) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align units.mul_inv_of_eq Units.mul_inv_of_eqₓ'. -/
 @[to_additive]
 theorem mul_inv_of_eq {a : α} (h : ↑u = a) : a * ↑u⁻¹ = 1 := by rw [← h, u.mul_inv]
 #align units.mul_inv_of_eq Units.mul_inv_of_eq
 #align add_units.add_neg_of_eq AddUnits.add_neg_of_eq
 
-/- warning: units.mul_inv_cancel_left -> Units.mul_inv_cancel_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) (b : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) a)) b)) b
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) (b : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) a)) b)) b
-Case conversion may be inaccurate. Consider using '#align units.mul_inv_cancel_left Units.mul_inv_cancel_leftₓ'. -/
 @[simp, to_additive]
 theorem mul_inv_cancel_left (a : αˣ) (b : α) : (a : α) * (↑a⁻¹ * b) = b := by
   rw [← mul_assoc, mul_inv, one_mul]
 #align units.mul_inv_cancel_left Units.mul_inv_cancel_left
 #align add_units.add_neg_cancel_left AddUnits.add_neg_cancel_left
 
-/- warning: units.inv_mul_cancel_left -> Units.inv_mul_cancel_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) (b : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) a) b)) b
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) (b : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 a) b)) b
-Case conversion may be inaccurate. Consider using '#align units.inv_mul_cancel_left Units.inv_mul_cancel_leftₓ'. -/
 @[simp, to_additive]
 theorem inv_mul_cancel_left (a : αˣ) (b : α) : (↑a⁻¹ : α) * (a * b) = b := by
   rw [← mul_assoc, inv_mul, one_mul]
 #align units.inv_mul_cancel_left Units.inv_mul_cancel_left
 #align add_units.neg_add_cancel_left AddUnits.neg_add_cancel_left
 
-/- warning: units.mul_inv_cancel_right -> Units.mul_inv_cancel_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) b)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) b))) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 b)) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) b))) a
-Case conversion may be inaccurate. Consider using '#align units.mul_inv_cancel_right Units.mul_inv_cancel_rightₓ'. -/
 @[simp, to_additive]
 theorem mul_inv_cancel_right (a : α) (b : αˣ) : a * b * ↑b⁻¹ = a := by
   rw [mul_assoc, mul_inv, mul_one]
 #align units.mul_inv_cancel_right Units.mul_inv_cancel_right
 #align add_units.add_neg_cancel_right AddUnits.add_neg_cancel_right
 
-/- warning: units.inv_mul_cancel_right -> Units.inv_mul_cancel_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) b))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) b)) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) b))) (Units.val.{u1} α _inst_1 b)) a
-Case conversion may be inaccurate. Consider using '#align units.inv_mul_cancel_right Units.inv_mul_cancel_rightₓ'. -/
 @[simp, to_additive]
 theorem inv_mul_cancel_right (a : α) (b : αˣ) : a * ↑b⁻¹ * b = a := by
   rw [mul_assoc, inv_mul, mul_one]
 #align units.inv_mul_cancel_right Units.inv_mul_cancel_right
 #align add_units.neg_add_cancel_right AddUnits.neg_add_cancel_right
 
-/- warning: units.mul_right_inj -> Units.mul_right_inj is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) {b : α} {c : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) a) b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) a) c)) (Eq.{succ u1} α b c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) {b : α} {c : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 a) b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 a) c)) (Eq.{succ u1} α b c)
-Case conversion may be inaccurate. Consider using '#align units.mul_right_inj Units.mul_right_injₓ'. -/
 @[simp, to_additive]
 theorem mul_right_inj (a : αˣ) {b c : α} : (a : α) * b = a * c ↔ b = c :=
   ⟨fun h => by simpa only [inv_mul_cancel_left] using congr_arg ((· * ·) ↑(a⁻¹ : αˣ)) h,
@@ -411,72 +306,36 @@ theorem mul_right_inj (a : αˣ) {b c : α} : (a : α) * b = a * c ↔ b = c :=
 #align units.mul_right_inj Units.mul_right_inj
 #align add_units.add_right_inj AddUnits.add_right_inj
 
-/- warning: units.mul_left_inj -> Units.mul_left_inj is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) {b : α} {c : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) b ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) c ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) a))) (Eq.{succ u1} α b c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) {b : α} {c : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) b (Units.val.{u1} α _inst_1 a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) c (Units.val.{u1} α _inst_1 a))) (Eq.{succ u1} α b c)
-Case conversion may be inaccurate. Consider using '#align units.mul_left_inj Units.mul_left_injₓ'. -/
 @[simp, to_additive]
 theorem mul_left_inj (a : αˣ) {b c : α} : b * a = c * a ↔ b = c :=
   ⟨fun h => by simpa only [mul_inv_cancel_right] using congr_arg (· * ↑(a⁻¹ : αˣ)) h, congr_arg _⟩
 #align units.mul_left_inj Units.mul_left_inj
 #align add_units.add_left_inj AddUnits.add_left_inj
 
-/- warning: units.eq_mul_inv_iff_mul_eq -> Units.eq_mul_inv_iff_mul_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (c : Units.{u1} α _inst_1) {a : α} {b : α}, Iff (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) b ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) c)))) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) c)) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (c : Units.{u1} α _inst_1) {a : α} {b : α}, Iff (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) b (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) c)))) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 c)) b)
-Case conversion may be inaccurate. Consider using '#align units.eq_mul_inv_iff_mul_eq Units.eq_mul_inv_iff_mul_eqₓ'. -/
 @[to_additive]
 theorem eq_mul_inv_iff_mul_eq {a b : α} : a = b * ↑c⁻¹ ↔ a * c = b :=
   ⟨fun h => by rw [h, inv_mul_cancel_right], fun h => by rw [← h, mul_inv_cancel_right]⟩
 #align units.eq_mul_inv_iff_mul_eq Units.eq_mul_inv_iff_mul_eq
 #align add_units.eq_add_neg_iff_add_eq AddUnits.eq_add_neg_iff_add_eq
 
-/- warning: units.eq_inv_mul_iff_mul_eq -> Units.eq_inv_mul_iff_mul_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (b : Units.{u1} α _inst_1) {a : α} {c : α}, Iff (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) b)) c)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) b) a) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (b : Units.{u1} α _inst_1) {a : α} {c : α}, Iff (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) b)) c)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 b) a) c)
-Case conversion may be inaccurate. Consider using '#align units.eq_inv_mul_iff_mul_eq Units.eq_inv_mul_iff_mul_eqₓ'. -/
 @[to_additive]
 theorem eq_inv_mul_iff_mul_eq {a c : α} : a = ↑b⁻¹ * c ↔ ↑b * a = c :=
   ⟨fun h => by rw [h, mul_inv_cancel_left], fun h => by rw [← h, inv_mul_cancel_left]⟩
 #align units.eq_inv_mul_iff_mul_eq Units.eq_inv_mul_iff_mul_eq
 #align add_units.eq_neg_add_iff_add_eq AddUnits.eq_neg_add_iff_add_eq
 
-/- warning: units.inv_mul_eq_iff_eq_mul -> Units.inv_mul_eq_iff_eq_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) {b : α} {c : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) a)) b) c) (Eq.{succ u1} α b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) a) c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) {b : α} {c : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) a)) b) c) (Eq.{succ u1} α b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 a) c))
-Case conversion may be inaccurate. Consider using '#align units.inv_mul_eq_iff_eq_mul Units.inv_mul_eq_iff_eq_mulₓ'. -/
 @[to_additive]
 theorem inv_mul_eq_iff_eq_mul {b c : α} : ↑a⁻¹ * b = c ↔ b = a * c :=
   ⟨fun h => by rw [← h, mul_inv_cancel_left], fun h => by rw [h, inv_mul_cancel_left]⟩
 #align units.inv_mul_eq_iff_eq_mul Units.inv_mul_eq_iff_eq_mul
 #align add_units.neg_add_eq_iff_eq_add AddUnits.neg_add_eq_iff_eq_add
 
-/- warning: units.mul_inv_eq_iff_eq_mul -> Units.mul_inv_eq_iff_eq_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (b : Units.{u1} α _inst_1) {a : α} {c : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) b))) c) (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) c ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (b : Units.{u1} α _inst_1) {a : α} {c : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) b))) c) (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) c (Units.val.{u1} α _inst_1 b)))
-Case conversion may be inaccurate. Consider using '#align units.mul_inv_eq_iff_eq_mul Units.mul_inv_eq_iff_eq_mulₓ'. -/
 @[to_additive]
 theorem mul_inv_eq_iff_eq_mul {a c : α} : a * ↑b⁻¹ = c ↔ a = c * b :=
   ⟨fun h => by rw [← h, inv_mul_cancel_right], fun h => by rw [h, mul_inv_cancel_right]⟩
 #align units.mul_inv_eq_iff_eq_mul Units.mul_inv_eq_iff_eq_mul
 #align add_units.add_neg_eq_iff_eq_add AddUnits.add_neg_eq_iff_eq_add
 
-/- warning: units.inv_eq_of_mul_eq_one_left -> Units.inv_eq_of_mul_eq_one_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) -> (Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 u)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) -> (Eq.{succ u1} α (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)) a)
-Case conversion may be inaccurate. Consider using '#align units.inv_eq_of_mul_eq_one_left Units.inv_eq_of_mul_eq_one_leftₓ'. -/
 @[to_additive]
 protected theorem inv_eq_of_mul_eq_one_left {a : α} (h : a * u = 1) : ↑u⁻¹ = a :=
   calc
@@ -486,12 +345,6 @@ protected theorem inv_eq_of_mul_eq_one_left {a : α} (h : a * u = 1) : ↑u⁻¹
 #align units.inv_eq_of_mul_eq_one_left Units.inv_eq_of_mul_eq_one_left
 #align add_units.neg_eq_of_add_eq_zero_left AddUnits.neg_eq_of_add_eq_zero_left
 
-/- warning: units.inv_eq_of_mul_eq_one_right -> Units.inv_eq_of_mul_eq_one_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) -> (Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 u) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) -> (Eq.{succ u1} α (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)) a)
-Case conversion may be inaccurate. Consider using '#align units.inv_eq_of_mul_eq_one_right Units.inv_eq_of_mul_eq_one_rightₓ'. -/
 @[to_additive]
 protected theorem inv_eq_of_mul_eq_one_right {a : α} (h : ↑u * a = 1) : ↑u⁻¹ = a :=
   calc
@@ -501,71 +354,35 @@ protected theorem inv_eq_of_mul_eq_one_right {a : α} (h : ↑u * a = 1) : ↑u
 #align units.inv_eq_of_mul_eq_one_right Units.inv_eq_of_mul_eq_one_right
 #align add_units.neg_eq_of_add_eq_zero_right AddUnits.neg_eq_of_add_eq_zero_right
 
-/- warning: units.eq_inv_of_mul_eq_one_left -> Units.eq_inv_of_mul_eq_one_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) -> (Eq.{succ u1} α a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 u) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) -> (Eq.{succ u1} α a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)))
-Case conversion may be inaccurate. Consider using '#align units.eq_inv_of_mul_eq_one_left Units.eq_inv_of_mul_eq_one_leftₓ'. -/
 @[to_additive]
 protected theorem eq_inv_of_mul_eq_one_left {a : α} (h : ↑u * a = 1) : a = ↑u⁻¹ :=
   (Units.inv_eq_of_mul_eq_one_right h).symm
 #align units.eq_inv_of_mul_eq_one_left Units.eq_inv_of_mul_eq_one_left
 #align add_units.eq_neg_of_add_eq_zero_left AddUnits.eq_neg_of_add_eq_zero_left
 
-/- warning: units.eq_inv_of_mul_eq_one_right -> Units.eq_inv_of_mul_eq_one_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) -> (Eq.{succ u1} α a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 u)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) -> (Eq.{succ u1} α a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)))
-Case conversion may be inaccurate. Consider using '#align units.eq_inv_of_mul_eq_one_right Units.eq_inv_of_mul_eq_one_rightₓ'. -/
 @[to_additive]
 protected theorem eq_inv_of_mul_eq_one_right {a : α} (h : a * u = 1) : a = ↑u⁻¹ :=
   (Units.inv_eq_of_mul_eq_one_left h).symm
 #align units.eq_inv_of_mul_eq_one_right Units.eq_inv_of_mul_eq_one_right
 #align add_units.eq_neg_of_add_eq_zero_right AddUnits.eq_neg_of_add_eq_zero_right
 
-/- warning: units.mul_inv_eq_one -> Units.mul_inv_eq_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (Eq.{succ u1} α a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (Eq.{succ u1} α a (Units.val.{u1} α _inst_1 u))
-Case conversion may be inaccurate. Consider using '#align units.mul_inv_eq_one Units.mul_inv_eq_oneₓ'. -/
 @[simp, to_additive]
 theorem mul_inv_eq_one {a : α} : a * ↑u⁻¹ = 1 ↔ a = u :=
   ⟨inv_inv u ▸ Units.eq_inv_of_mul_eq_one_right, fun h => mul_inv_of_eq h.symm⟩
 #align units.mul_inv_eq_one Units.mul_inv_eq_one
 #align add_units.add_neg_eq_zero AddUnits.add_neg_eq_zero
 
-/- warning: units.inv_mul_eq_one -> Units.inv_mul_eq_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (Eq.{succ u1} α (Units.val.{u1} α _inst_1 u) a)
-Case conversion may be inaccurate. Consider using '#align units.inv_mul_eq_one Units.inv_mul_eq_oneₓ'. -/
 @[simp, to_additive]
 theorem inv_mul_eq_one {a : α} : ↑u⁻¹ * a = 1 ↔ ↑u = a :=
   ⟨inv_inv u ▸ Units.inv_eq_of_mul_eq_one_right, inv_mul_of_eq⟩
 #align units.inv_mul_eq_one Units.inv_mul_eq_one
 #align add_units.neg_add_eq_zero AddUnits.neg_add_eq_zero
 
-/- warning: units.mul_eq_one_iff_eq_inv -> Units.mul_eq_one_iff_eq_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (Eq.{succ u1} α a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 u)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (Eq.{succ u1} α a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)))
-Case conversion may be inaccurate. Consider using '#align units.mul_eq_one_iff_eq_inv Units.mul_eq_one_iff_eq_invₓ'. -/
 @[to_additive]
 theorem mul_eq_one_iff_eq_inv {a : α} : a * u = 1 ↔ a = ↑u⁻¹ := by rw [← mul_inv_eq_one, inv_inv]
 #align units.mul_eq_one_iff_eq_inv Units.mul_eq_one_iff_eq_inv
 #align add_units.add_eq_zero_iff_eq_neg AddUnits.add_eq_zero_iff_eq_neg
 
-/- warning: units.mul_eq_one_iff_inv_eq -> Units.mul_eq_one_iff_inv_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 u) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (Eq.{succ u1} α (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)) a)
-Case conversion may be inaccurate. Consider using '#align units.mul_eq_one_iff_inv_eq Units.mul_eq_one_iff_inv_eqₓ'. -/
 @[to_additive]
 theorem mul_eq_one_iff_inv_eq {a : α} : ↑u * a = 1 ↔ ↑u⁻¹ = a := by rw [← inv_mul_eq_one, inv_inv]
 #align units.mul_eq_one_iff_inv_eq Units.mul_eq_one_iff_inv_eq
@@ -579,12 +396,6 @@ theorem inv_unique {u₁ u₂ : αˣ} (h : (↑u₁ : α) = ↑u₂) : (↑u₁
 #align add_units.neg_unique AddUnits.neg_unique
 -/
 
-/- warning: units.coe_inv -> Units.val_inv_eq_inv_val is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_2 : DivisionMonoid.{u1} M] (u : Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))), Eq.{succ u1} M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) M (coeBase.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) M (Units.hasCoe.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2)))))) (Inv.inv.{u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) (Units.hasInv.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) u)) (Inv.inv.{u1} M (DivInvMonoid.toHasInv.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) M (coeBase.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) M (Units.hasCoe.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2)))))) u))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_2 : DivisionMonoid.{u1} M] (u : Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))), Eq.{succ u1} M (Units.val.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2)) (Inv.inv.{u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) (Units.instInv.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) u)) (Inv.inv.{u1} M (InvOneClass.toInv.{u1} M (DivInvOneMonoid.toInvOneClass.{u1} M (DivisionMonoid.toDivInvOneMonoid.{u1} M _inst_2))) (Units.val.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2)) u))
-Case conversion may be inaccurate. Consider using '#align units.coe_inv Units.val_inv_eq_inv_valₓ'. -/
 @[simp, to_additive]
 theorem val_inv_eq_inv_val {M : Type _} [DivisionMonoid M] (u : Units M) : ↑u⁻¹ = (u⁻¹ : M) :=
   Eq.symm <| inv_eq_of_mul_eq_one_right u.mul_inv
@@ -593,12 +404,6 @@ theorem val_inv_eq_inv_val {M : Type _} [DivisionMonoid M] (u : Units M) : ↑u
 
 end Units
 
-/- warning: units.mk_of_mul_eq_one -> Units.mkOfMulEqOne is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (a : α) (b : α), (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))) -> (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (a : α) (b : α), (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))) -> (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))
-Case conversion may be inaccurate. Consider using '#align units.mk_of_mul_eq_one Units.mkOfMulEqOneₓ'. -/
 /-- For `a, b` in a `comm_monoid` such that `a * b = 1`, makes a unit out of `a`. -/
 @[to_additive
       "For `a, b` in an `add_comm_monoid` such that `a + b = 0`, makes an add_unit\nout of `a`."]
@@ -607,12 +412,6 @@ def Units.mkOfMulEqOne [CommMonoid α] (a b : α) (hab : a * b = 1) : αˣ :=
 #align units.mk_of_mul_eq_one Units.mkOfMulEqOne
 #align add_units.mk_of_add_eq_zero AddUnits.mkOfAddEqZero
 
-/- warning: units.coe_mk_of_mul_eq_one -> Units.val_mkOfMulEqOne is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] {a : α} {b : α} (h : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))), Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) α (coeBase.{succ u1, succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) α (Units.hasCoe.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))) (Units.mkOfMulEqOne.{u1} α _inst_1 a b h)) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] {a : α} {b : α} (h : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))), Eq.{succ u1} α (Units.val.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) (Units.mkOfMulEqOne.{u1} α _inst_1 a b h)) a
-Case conversion may be inaccurate. Consider using '#align units.coe_mk_of_mul_eq_one Units.val_mkOfMulEqOneₓ'. -/
 @[simp, to_additive]
 theorem Units.val_mkOfMulEqOne [CommMonoid α] {a b : α} (h : a * b = 1) :
     (Units.mkOfMulEqOne a b h : α) = a :=
@@ -636,78 +435,36 @@ def divp (a : α) (u) : α :=
 -- mathport name: «expr /ₚ »
 infixl:70 " /ₚ " => divp
 
-/- warning: divp_self -> divp_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u) u) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 (Units.val.{u1} α _inst_1 u) u) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align divp_self divp_selfₓ'. -/
 @[simp]
 theorem divp_self (u : αˣ) : (u : α) /ₚ u = 1 :=
   Units.mul_inv _
 #align divp_self divp_self
 
-/- warning: divp_one -> divp_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α), Eq.{succ u1} α (divp.{u1} α _inst_1 a (OfNat.ofNat.{u1} (Units.{u1} α _inst_1) 1 (OfNat.mk.{u1} (Units.{u1} α _inst_1) 1 (One.one.{u1} (Units.{u1} α _inst_1) (MulOneClass.toHasOne.{u1} (Units.{u1} α _inst_1) (Units.mulOneClass.{u1} α _inst_1)))))) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α), Eq.{succ u1} α (divp.{u1} α _inst_1 a (OfNat.ofNat.{u1} (Units.{u1} α _inst_1) 1 (One.toOfNat1.{u1} (Units.{u1} α _inst_1) (InvOneClass.toOne.{u1} (Units.{u1} α _inst_1) (DivInvOneMonoid.toInvOneClass.{u1} (Units.{u1} α _inst_1) (DivisionMonoid.toDivInvOneMonoid.{u1} (Units.{u1} α _inst_1) (Group.toDivisionMonoid.{u1} (Units.{u1} α _inst_1) (Units.instGroupUnits.{u1} α _inst_1)))))))) a
-Case conversion may be inaccurate. Consider using '#align divp_one divp_oneₓ'. -/
 @[simp]
 theorem divp_one (a : α) : a /ₚ 1 = a :=
   mul_one _
 #align divp_one divp_one
 
-/- warning: divp_assoc -> divp_assoc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) (u : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a b) u) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (divp.{u1} α _inst_1 b u))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) (u : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a b) u) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (divp.{u1} α _inst_1 b u))
-Case conversion may be inaccurate. Consider using '#align divp_assoc divp_assocₓ'. -/
 theorem divp_assoc (a b : α) (u : αˣ) : a * b /ₚ u = a * (b /ₚ u) :=
   mul_assoc _ _ _
 #align divp_assoc divp_assoc
 
-/- warning: divp_assoc' -> divp_assoc' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (x : α) (y : α) (u : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) x (divp.{u1} α _inst_1 y u)) (divp.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) x y) u)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (x : α) (y : α) (u : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) x (divp.{u1} α _inst_1 y u)) (divp.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) x y) u)
-Case conversion may be inaccurate. Consider using '#align divp_assoc' divp_assoc'ₓ'. -/
 /-- `field_simp` needs the reverse direction of `divp_assoc` to move all `/ₚ` to the right. -/
 @[field_simps]
 theorem divp_assoc' (x y : α) (u : αˣ) : x * (y /ₚ u) = x * y /ₚ u :=
   (divp_assoc _ _ _).symm
 #align divp_assoc' divp_assoc'
 
-/- warning: divp_inv -> divp_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} (u : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 a (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} (u : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 a (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 u))
-Case conversion may be inaccurate. Consider using '#align divp_inv divp_invₓ'. -/
 @[simp]
 theorem divp_inv (u : αˣ) : a /ₚ u⁻¹ = a * u :=
   rfl
 #align divp_inv divp_inv
 
-/- warning: divp_mul_cancel -> divp_mul_cancel is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (u : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (divp.{u1} α _inst_1 a u) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u)) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (u : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (divp.{u1} α _inst_1 a u) (Units.val.{u1} α _inst_1 u)) a
-Case conversion may be inaccurate. Consider using '#align divp_mul_cancel divp_mul_cancelₓ'. -/
 @[simp]
 theorem divp_mul_cancel (a : α) (u : αˣ) : a /ₚ u * u = a :=
   (mul_assoc _ _ _).trans <| by rw [Units.inv_mul, mul_one]
 #align divp_mul_cancel divp_mul_cancel
 
-/- warning: mul_divp_cancel -> mul_divp_cancel is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (u : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u)) u) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (u : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 u)) u) a
-Case conversion may be inaccurate. Consider using '#align mul_divp_cancel mul_divp_cancelₓ'. -/
 @[simp]
 theorem mul_divp_cancel (a : α) (u : αˣ) : a * u /ₚ u = a :=
   (mul_assoc _ _ _).trans <| by rw [Units.mul_inv, mul_one]
@@ -720,77 +477,35 @@ theorem divp_left_inj (u : αˣ) {a b : α} : a /ₚ u = b /ₚ u ↔ a = b :=
 #align divp_left_inj divp_left_inj
 -/
 
-/- warning: divp_divp_eq_divp_mul -> divp_divp_eq_divp_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (x : α) (u₁ : Units.{u1} α _inst_1) (u₂ : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 (divp.{u1} α _inst_1 x u₁) u₂) (divp.{u1} α _inst_1 x (HMul.hMul.{u1, u1, u1} (Units.{u1} α _inst_1) (Units.{u1} α _inst_1) (Units.{u1} α _inst_1) (instHMul.{u1} (Units.{u1} α _inst_1) (MulOneClass.toHasMul.{u1} (Units.{u1} α _inst_1) (Units.mulOneClass.{u1} α _inst_1))) u₂ u₁))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (x : α) (u₁ : Units.{u1} α _inst_1) (u₂ : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 (divp.{u1} α _inst_1 x u₁) u₂) (divp.{u1} α _inst_1 x (HMul.hMul.{u1, u1, u1} (Units.{u1} α _inst_1) (Units.{u1} α _inst_1) (Units.{u1} α _inst_1) (instHMul.{u1} (Units.{u1} α _inst_1) (MulOneClass.toMul.{u1} (Units.{u1} α _inst_1) (Units.instMulOneClassUnits.{u1} α _inst_1))) u₂ u₁))
-Case conversion may be inaccurate. Consider using '#align divp_divp_eq_divp_mul divp_divp_eq_divp_mulₓ'. -/
 @[field_simps]
 theorem divp_divp_eq_divp_mul (x : α) (u₁ u₂ : αˣ) : x /ₚ u₁ /ₚ u₂ = x /ₚ (u₂ * u₁) := by
   simp only [divp, mul_inv_rev, Units.val_mul, mul_assoc]
 #align divp_divp_eq_divp_mul divp_divp_eq_divp_mul
 
-/- warning: divp_eq_iff_mul_eq -> divp_eq_iff_mul_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {x : α} {u : Units.{u1} α _inst_1} {y : α}, Iff (Eq.{succ u1} α (divp.{u1} α _inst_1 x u) y) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u)) x)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {x : α} {u : Units.{u1} α _inst_1} {y : α}, Iff (Eq.{succ u1} α (divp.{u1} α _inst_1 x u) y) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) y (Units.val.{u1} α _inst_1 u)) x)
-Case conversion may be inaccurate. Consider using '#align divp_eq_iff_mul_eq divp_eq_iff_mul_eqₓ'. -/
 @[field_simps]
 theorem divp_eq_iff_mul_eq {x : α} {u : αˣ} {y : α} : x /ₚ u = y ↔ y * u = x :=
   u.mul_left_inj.symm.trans <| by rw [divp_mul_cancel] <;> exact ⟨Eq.symm, Eq.symm⟩
 #align divp_eq_iff_mul_eq divp_eq_iff_mul_eq
 
-/- warning: eq_divp_iff_mul_eq -> eq_divp_iff_mul_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {x : α} {u : Units.{u1} α _inst_1} {y : α}, Iff (Eq.{succ u1} α x (divp.{u1} α _inst_1 y u)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) x ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u)) y)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {x : α} {u : Units.{u1} α _inst_1} {y : α}, Iff (Eq.{succ u1} α x (divp.{u1} α _inst_1 y u)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) x (Units.val.{u1} α _inst_1 u)) y)
-Case conversion may be inaccurate. Consider using '#align eq_divp_iff_mul_eq eq_divp_iff_mul_eqₓ'. -/
 @[field_simps]
 theorem eq_divp_iff_mul_eq {x : α} {u : αˣ} {y : α} : x = y /ₚ u ↔ x * u = y := by
   rw [eq_comm, divp_eq_iff_mul_eq]
 #align eq_divp_iff_mul_eq eq_divp_iff_mul_eq
 
-/- warning: divp_eq_one_iff_eq -> divp_eq_one_iff_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} {u : Units.{u1} α _inst_1}, Iff (Eq.{succ u1} α (divp.{u1} α _inst_1 a u) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (Eq.{succ u1} α a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} {u : Units.{u1} α _inst_1}, Iff (Eq.{succ u1} α (divp.{u1} α _inst_1 a u) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (Eq.{succ u1} α a (Units.val.{u1} α _inst_1 u))
-Case conversion may be inaccurate. Consider using '#align divp_eq_one_iff_eq divp_eq_one_iff_eqₓ'. -/
 theorem divp_eq_one_iff_eq {a : α} {u : αˣ} : a /ₚ u = 1 ↔ a = u :=
   (Units.mul_left_inj u).symm.trans <| by rw [divp_mul_cancel, one_mul]
 #align divp_eq_one_iff_eq divp_eq_one_iff_eq
 
-/- warning: one_divp -> one_divp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))))) u) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))) u) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u))
-Case conversion may be inaccurate. Consider using '#align one_divp one_divpₓ'. -/
 @[simp]
 theorem one_divp (u : αˣ) : 1 /ₚ u = ↑u⁻¹ :=
   one_mul _
 #align one_divp one_divp
 
-/- warning: inv_eq_one_divp -> inv_eq_one_divp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1), Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)) (divp.{u1} α _inst_1 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))))) u)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1), Eq.{succ u1} α (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)) (divp.{u1} α _inst_1 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))) u)
-Case conversion may be inaccurate. Consider using '#align inv_eq_one_divp inv_eq_one_divpₓ'. -/
 /-- Used for `field_simp` to deal with inverses of units. -/
 @[field_simps]
 theorem inv_eq_one_divp (u : αˣ) : ↑u⁻¹ = 1 /ₚ u := by rw [one_divp]
 #align inv_eq_one_divp inv_eq_one_divp
 
-/- warning: inv_eq_one_divp' -> inv_eq_one_divp' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1), Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (HDiv.hDiv.{u1, u1, u1} (Units.{u1} α _inst_1) (Units.{u1} α _inst_1) (Units.{u1} α _inst_1) (instHDiv.{u1} (Units.{u1} α _inst_1) (DivInvMonoid.toHasDiv.{u1} (Units.{u1} α _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} α _inst_1) (Units.group.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (Units.{u1} α _inst_1) 1 (OfNat.mk.{u1} (Units.{u1} α _inst_1) 1 (One.one.{u1} (Units.{u1} α _inst_1) (MulOneClass.toHasOne.{u1} (Units.{u1} α _inst_1) (Units.mulOneClass.{u1} α _inst_1))))) u)) (divp.{u1} α _inst_1 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))))) u)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1), Eq.{succ u1} α (Units.val.{u1} α _inst_1 (HDiv.hDiv.{u1, u1, u1} (Units.{u1} α _inst_1) (Units.{u1} α _inst_1) (Units.{u1} α _inst_1) (instHDiv.{u1} (Units.{u1} α _inst_1) (DivInvMonoid.toDiv.{u1} (Units.{u1} α _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} α _inst_1) (Units.instGroupUnits.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (Units.{u1} α _inst_1) 1 (One.toOfNat1.{u1} (Units.{u1} α _inst_1) (InvOneClass.toOne.{u1} (Units.{u1} α _inst_1) (DivInvOneMonoid.toInvOneClass.{u1} (Units.{u1} α _inst_1) (DivisionMonoid.toDivInvOneMonoid.{u1} (Units.{u1} α _inst_1) (Group.toDivisionMonoid.{u1} (Units.{u1} α _inst_1) (Units.instGroupUnits.{u1} α _inst_1))))))) u)) (divp.{u1} α _inst_1 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))) u)
-Case conversion may be inaccurate. Consider using '#align inv_eq_one_divp' inv_eq_one_divp'ₓ'. -/
 /-- Used for `field_simp` to deal with inverses of units. This form of the lemma
 is essential since `field_simp` likes to use `inv_eq_one_div` to rewrite
 `↑u⁻¹ = ↑(1 / u)`.
@@ -799,12 +514,6 @@ is essential since `field_simp` likes to use `inv_eq_one_div` to rewrite
 theorem inv_eq_one_divp' (u : αˣ) : ((1 / u : αˣ) : α) = 1 /ₚ u := by rw [one_div, one_divp]
 #align inv_eq_one_divp' inv_eq_one_divp'
 
-/- warning: coe_div_eq_divp -> val_div_eq_divp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u₁ : Units.{u1} α _inst_1) (u₂ : Units.{u1} α _inst_1), Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (HDiv.hDiv.{u1, u1, u1} (Units.{u1} α _inst_1) (Units.{u1} α _inst_1) (Units.{u1} α _inst_1) (instHDiv.{u1} (Units.{u1} α _inst_1) (DivInvMonoid.toHasDiv.{u1} (Units.{u1} α _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} α _inst_1) (Units.group.{u1} α _inst_1)))) u₁ u₂)) (divp.{u1} α _inst_1 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u₁) u₂)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u₁ : Units.{u1} α _inst_1) (u₂ : Units.{u1} α _inst_1), Eq.{succ u1} α (Units.val.{u1} α _inst_1 (HDiv.hDiv.{u1, u1, u1} (Units.{u1} α _inst_1) (Units.{u1} α _inst_1) (Units.{u1} α _inst_1) (instHDiv.{u1} (Units.{u1} α _inst_1) (DivInvMonoid.toDiv.{u1} (Units.{u1} α _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} α _inst_1) (Units.instGroupUnits.{u1} α _inst_1)))) u₁ u₂)) (divp.{u1} α _inst_1 (Units.val.{u1} α _inst_1 u₁) u₂)
-Case conversion may be inaccurate. Consider using '#align coe_div_eq_divp val_div_eq_divpₓ'. -/
 /-- `field_simp` moves division inside `αˣ` to the right, and this lemma
 lifts the calculation to `α`.
 -/
@@ -819,35 +528,17 @@ section CommMonoid
 
 variable [CommMonoid α]
 
-/- warning: divp_mul_eq_mul_divp -> divp_mul_eq_mul_divp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (x : α) (y : α) (u : Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (divp.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) x u) y) (divp.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) u)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (x : α) (y : α) (u : Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (divp.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) x u) y) (divp.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) u)
-Case conversion may be inaccurate. Consider using '#align divp_mul_eq_mul_divp divp_mul_eq_mul_divpₓ'. -/
 @[field_simps]
 theorem divp_mul_eq_mul_divp (x y : α) (u : αˣ) : x /ₚ u * y = x * y /ₚ u := by
   simp_rw [divp, mul_assoc, mul_comm]
 #align divp_mul_eq_mul_divp divp_mul_eq_mul_divp
 
-/- warning: divp_eq_divp_iff -> divp_eq_divp_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] {x : α} {y : α} {ux : Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)} {uy : Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)}, Iff (Eq.{succ u1} α (divp.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) x ux) (divp.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) y uy)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) α (coeBase.{succ u1, succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) α (Units.hasCoe.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))) uy)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) α (coeBase.{succ u1, succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) α (Units.hasCoe.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))) ux)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] {x : α} {y : α} {ux : Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)} {uy : Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)}, Iff (Eq.{succ u1} α (divp.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) x ux) (divp.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) y uy)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (Units.val.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) uy)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y (Units.val.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) ux)))
-Case conversion may be inaccurate. Consider using '#align divp_eq_divp_iff divp_eq_divp_iffₓ'. -/
 -- Theoretically redundant as `field_simp` lemma.
 @[field_simps]
 theorem divp_eq_divp_iff {x y : α} {ux uy : αˣ} : x /ₚ ux = y /ₚ uy ↔ x * uy = y * ux := by
   rw [divp_eq_iff_mul_eq, divp_mul_eq_mul_divp, divp_eq_iff_mul_eq]
 #align divp_eq_divp_iff divp_eq_divp_iff
 
-/- warning: divp_mul_divp -> divp_mul_divp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (x : α) (y : α) (ux : Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (uy : Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (divp.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) x ux) (divp.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) y uy)) (divp.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) (HMul.hMul.{u1, u1, u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (instHMul.{u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (MulOneClass.toHasMul.{u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Units.mulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) ux uy))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (x : α) (y : α) (ux : Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (uy : Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (divp.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) x ux) (divp.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) y uy)) (divp.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) (HMul.hMul.{u1, u1, u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (instHMul.{u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Units.instMulOneClassUnits.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) ux uy))
-Case conversion may be inaccurate. Consider using '#align divp_mul_divp divp_mul_divpₓ'. -/
 -- Theoretically redundant as `field_simp` lemma.
 @[field_simps]
 theorem divp_mul_divp (x y : α) (ux uy : αˣ) : x /ₚ ux * (y /ₚ uy) = x * y /ₚ (ux * uy) := by
@@ -856,36 +547,18 @@ theorem divp_mul_divp (x y : α) (ux uy : αˣ) : x /ₚ ux * (y /ₚ uy) = x *
 
 variable [Subsingleton αˣ] {a b : α}
 
-/- warning: eq_one_of_mul_right -> eq_one_of_mul_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : Subsingleton.{succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))] {a : α} {b : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))) -> (Eq.{succ u1} α a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : Subsingleton.{succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))] {a : α} {b : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))) -> (Eq.{succ u1} α a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align eq_one_of_mul_right eq_one_of_mul_rightₓ'. -/
 @[to_additive]
 theorem eq_one_of_mul_right (h : a * b = 1) : a = 1 :=
   congr_arg Units.inv <| Subsingleton.elim (Units.mk _ _ (by rwa [mul_comm]) h) 1
 #align eq_one_of_mul_right eq_one_of_mul_right
 #align eq_zero_of_add_right eq_zero_of_add_right
 
-/- warning: eq_one_of_mul_left -> eq_one_of_mul_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : Subsingleton.{succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))] {a : α} {b : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))) -> (Eq.{succ u1} α b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : Subsingleton.{succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))] {a : α} {b : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))) -> (Eq.{succ u1} α b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align eq_one_of_mul_left eq_one_of_mul_leftₓ'. -/
 @[to_additive]
 theorem eq_one_of_mul_left (h : a * b = 1) : b = 1 :=
   congr_arg Units.inv <| Subsingleton.elim (Units.mk _ _ h <| by rwa [mul_comm]) 1
 #align eq_one_of_mul_left eq_one_of_mul_left
 #align eq_zero_of_add_left eq_zero_of_add_left
 
-/- warning: mul_eq_one -> mul_eq_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : Subsingleton.{succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))] {a : α} {b : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))) (And (Eq.{succ u1} α a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))) (Eq.{succ u1} α b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : Subsingleton.{succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))] {a : α} {b : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))) (And (Eq.{succ u1} α a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))) (Eq.{succ u1} α b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align mul_eq_one mul_eq_oneₓ'. -/
 @[simp, to_additive]
 theorem mul_eq_one : a * b = 1 ↔ a = 1 ∧ b = 1 :=
   ⟨fun h => ⟨eq_one_of_mul_right h, eq_one_of_mul_left h⟩, by rintro ⟨rfl, rfl⟩; exact mul_one _⟩
@@ -947,96 +620,48 @@ protected theorem Units.isUnit [Monoid M] (u : Mˣ) : IsUnit (u : M) :=
 #align add_units.is_add_unit_add_unit AddUnits.isAddUnit
 -/
 
-/- warning: is_unit_one -> isUnit_one is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], IsUnit.{u1} M _inst_1 (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], IsUnit.{u1} M _inst_1 (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))
-Case conversion may be inaccurate. Consider using '#align is_unit_one isUnit_oneₓ'. -/
 @[simp, to_additive]
 theorem isUnit_one [Monoid M] : IsUnit (1 : M) :=
   ⟨1, rfl⟩
 #align is_unit_one isUnit_one
 #align is_add_unit_zero isAddUnit_zero
 
-/- warning: is_unit_of_mul_eq_one -> isUnit_of_mul_eq_one is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : CommMonoid.{u1} M] (a : M) (b : M), (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1)))) a b) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1))))))) -> (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) a)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : CommMonoid.{u1} M] (a : M) (b : M), (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1)))) a b) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1))))) -> (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align is_unit_of_mul_eq_one isUnit_of_mul_eq_oneₓ'. -/
 @[to_additive]
 theorem isUnit_of_mul_eq_one [CommMonoid M] (a b : M) (h : a * b = 1) : IsUnit a :=
   ⟨Units.mkOfMulEqOne a b h, rfl⟩
 #align is_unit_of_mul_eq_one isUnit_of_mul_eq_one
 #align is_add_unit_of_add_eq_zero isAddUnit_of_add_eq_zero
 
-/- warning: is_unit.exists_right_inv -> IsUnit.exists_right_inv is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Exists.{succ u1} M (fun (b : M) => Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a b) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Exists.{succ u1} M (fun (b : M) => Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a b) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align is_unit.exists_right_inv IsUnit.exists_right_invₓ'. -/
 @[to_additive IsAddUnit.exists_neg]
 theorem IsUnit.exists_right_inv [Monoid M] {a : M} (h : IsUnit a) : ∃ b, a * b = 1 := by
   rcases h with ⟨⟨a, b, hab, _⟩, rfl⟩; exact ⟨b, hab⟩
 #align is_unit.exists_right_inv IsUnit.exists_right_inv
 #align is_add_unit.exists_neg IsAddUnit.exists_neg
 
-/- warning: is_unit.exists_left_inv -> IsUnit.exists_left_inv is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Exists.{succ u1} M (fun (b : M) => Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) b a) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Exists.{succ u1} M (fun (b : M) => Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) b a) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align is_unit.exists_left_inv IsUnit.exists_left_invₓ'. -/
 @[to_additive IsAddUnit.exists_neg']
 theorem IsUnit.exists_left_inv [Monoid M] {a : M} (h : IsUnit a) : ∃ b, b * a = 1 := by
   rcases h with ⟨⟨a, b, _, hba⟩, rfl⟩; exact ⟨b, hba⟩
 #align is_unit.exists_left_inv IsUnit.exists_left_inv
 #align is_add_unit.exists_neg' IsAddUnit.exists_neg'
 
-/- warning: is_unit_iff_exists_inv -> isUnit_iff_exists_inv is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : CommMonoid.{u1} M] {a : M}, Iff (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) a) (Exists.{succ u1} M (fun (b : M) => Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1)))) a b) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1))))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : CommMonoid.{u1} M] {a : M}, Iff (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) a) (Exists.{succ u1} M (fun (b : M) => Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1)))) a b) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align is_unit_iff_exists_inv isUnit_iff_exists_invₓ'. -/
 @[to_additive]
 theorem isUnit_iff_exists_inv [CommMonoid M] {a : M} : IsUnit a ↔ ∃ b, a * b = 1 :=
   ⟨fun h => h.exists_right_inv, fun ⟨b, hab⟩ => isUnit_of_mul_eq_one _ b hab⟩
 #align is_unit_iff_exists_inv isUnit_iff_exists_inv
 #align is_add_unit_iff_exists_neg isAddUnit_iff_exists_neg
 
-/- warning: is_unit_iff_exists_inv' -> isUnit_iff_exists_inv' is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : CommMonoid.{u1} M] {a : M}, Iff (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) a) (Exists.{succ u1} M (fun (b : M) => Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1)))) b a) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1))))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : CommMonoid.{u1} M] {a : M}, Iff (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) a) (Exists.{succ u1} M (fun (b : M) => Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1)))) b a) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align is_unit_iff_exists_inv' isUnit_iff_exists_inv'ₓ'. -/
 @[to_additive]
 theorem isUnit_iff_exists_inv' [CommMonoid M] {a : M} : IsUnit a ↔ ∃ b, b * a = 1 := by
   simp [isUnit_iff_exists_inv, mul_comm]
 #align is_unit_iff_exists_inv' isUnit_iff_exists_inv'
 #align is_add_unit_iff_exists_neg' isAddUnit_iff_exists_neg'
 
-/- warning: is_unit.mul -> IsUnit.mul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {x : M} {y : M}, (IsUnit.{u1} M _inst_1 x) -> (IsUnit.{u1} M _inst_1 y) -> (IsUnit.{u1} M _inst_1 (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x y))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {x : M} {y : M}, (IsUnit.{u1} M _inst_1 x) -> (IsUnit.{u1} M _inst_1 y) -> (IsUnit.{u1} M _inst_1 (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x y))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul IsUnit.mulₓ'. -/
 @[to_additive]
 theorem IsUnit.mul [Monoid M] {x y : M} : IsUnit x → IsUnit y → IsUnit (x * y) := by
   rintro ⟨x, rfl⟩ ⟨y, rfl⟩; exact ⟨x * y, Units.val_mul _ _⟩
 #align is_unit.mul IsUnit.mul
 #align is_add_unit.add IsAddUnit.add
 
-/- warning: units.is_unit_mul_units -> Units.isUnit_mul_units is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (a : M) (u : Units.{u1} M _inst_1), Iff (IsUnit.{u1} M _inst_1 (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) u))) (IsUnit.{u1} M _inst_1 a)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (a : M) (u : Units.{u1} M _inst_1), Iff (IsUnit.{u1} M _inst_1 (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a (Units.val.{u1} M _inst_1 u))) (IsUnit.{u1} M _inst_1 a)
-Case conversion may be inaccurate. Consider using '#align units.is_unit_mul_units Units.isUnit_mul_unitsₓ'. -/
 /-- Multiplication by a `u : Mˣ` on the right doesn't affect `is_unit`. -/
 @[simp, to_additive "Addition of a `u : add_units M` on the right doesn't\naffect `is_add_unit`."]
 theorem Units.isUnit_mul_units [Monoid M] (a : M) (u : Mˣ) : IsUnit (a * u) ↔ IsUnit a :=
@@ -1049,12 +674,6 @@ theorem Units.isUnit_mul_units [Monoid M] (a : M) (u : Mˣ) : IsUnit (a * u) ↔
 #align units.is_unit_mul_units Units.isUnit_mul_units
 #align add_units.is_add_unit_add_add_units AddUnits.isAddUnit_add_addUnits
 
-/- warning: units.is_unit_units_mul -> Units.isUnit_units_mul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (u : Units.{u1} M _inst_1) (a : M), Iff (IsUnit.{u1} M _inst_1 (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) u) a)) (IsUnit.{u1} M _inst_1 a)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (u : Units.{u1} M _inst_1) (a : M), Iff (IsUnit.{u1} M _inst_1 (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Units.val.{u1} M _inst_1 u) a)) (IsUnit.{u1} M _inst_1 a)
-Case conversion may be inaccurate. Consider using '#align units.is_unit_units_mul Units.isUnit_units_mulₓ'. -/
 /-- Multiplication by a `u : Mˣ` on the left doesn't affect `is_unit`. -/
 @[simp, to_additive "Addition of a `u : add_units M` on the left doesn't affect `is_add_unit`."]
 theorem Units.isUnit_units_mul {M : Type _} [Monoid M] (u : Mˣ) (a : M) :
@@ -1068,12 +687,6 @@ theorem Units.isUnit_units_mul {M : Type _} [Monoid M] (u : Mˣ) (a : M) :
 #align units.is_unit_units_mul Units.isUnit_units_mul
 #align add_units.is_add_unit_add_units_add AddUnits.isAddUnit_addUnits_add
 
-/- warning: is_unit_of_mul_is_unit_left -> isUnit_of_mul_isUnit_left is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : CommMonoid.{u1} M] {x : M} {y : M}, (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1)))) x y)) -> (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) x)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : CommMonoid.{u1} M] {x : M} {y : M}, (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1)))) x y)) -> (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) x)
-Case conversion may be inaccurate. Consider using '#align is_unit_of_mul_is_unit_left isUnit_of_mul_isUnit_leftₓ'. -/
 @[to_additive]
 theorem isUnit_of_mul_isUnit_left [CommMonoid M] {x y : M} (hu : IsUnit (x * y)) : IsUnit x :=
   let ⟨z, hz⟩ := isUnit_iff_exists_inv.1 hu
@@ -1081,12 +694,6 @@ theorem isUnit_of_mul_isUnit_left [CommMonoid M] {x y : M} (hu : IsUnit (x * y))
 #align is_unit_of_mul_is_unit_left isUnit_of_mul_isUnit_left
 #align is_add_unit_of_add_is_add_unit_left isAddUnit_of_add_isAddUnit_left
 
-/- warning: is_unit_of_mul_is_unit_right -> isUnit_of_mul_isUnit_right is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : CommMonoid.{u1} M] {x : M} {y : M}, (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1)))) x y)) -> (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) y)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : CommMonoid.{u1} M] {x : M} {y : M}, (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1)))) x y)) -> (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) y)
-Case conversion may be inaccurate. Consider using '#align is_unit_of_mul_is_unit_right isUnit_of_mul_isUnit_rightₓ'. -/
 @[to_additive]
 theorem isUnit_of_mul_isUnit_right [CommMonoid M] {x y : M} (hu : IsUnit (x * y)) : IsUnit y :=
   @isUnit_of_mul_isUnit_left _ _ y x <| by rwa [mul_comm]
@@ -1095,12 +702,6 @@ theorem isUnit_of_mul_isUnit_right [CommMonoid M] {x y : M} (hu : IsUnit (x * y)
 
 namespace IsUnit
 
-/- warning: is_unit.mul_iff -> IsUnit.mul_iff is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : CommMonoid.{u1} M] {x : M} {y : M}, Iff (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1)))) x y)) (And (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) x) (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) y))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : CommMonoid.{u1} M] {x : M} {y : M}, Iff (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1)))) x y)) (And (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) x) (IsUnit.{u1} M (CommMonoid.toMonoid.{u1} M _inst_1) y))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_iff IsUnit.mul_iffₓ'. -/
 @[simp, to_additive]
 theorem mul_iff [CommMonoid M] {x y : M} : IsUnit (x * y) ↔ IsUnit x ∧ IsUnit y :=
   ⟨fun h => ⟨isUnit_of_mul_isUnit_left h, isUnit_of_mul_isUnit_right h⟩, fun h =>
@@ -1139,24 +740,12 @@ theorem unit_spec (h : IsUnit a) : ↑h.Unit = a :=
 #align is_add_unit.add_unit_spec IsAddUnit.addUnit_spec
 -/
 
-/- warning: is_unit.coe_inv_mul -> IsUnit.val_inv_mul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} (h : IsUnit.{u1} M _inst_1 a), Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.hasInv.{u1} M _inst_1) (IsUnit.unit.{u1} M _inst_1 a h))) a) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} (h : IsUnit.{u1} M _inst_1 a), Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInv.{u1} M _inst_1) (IsUnit.unit.{u1} M _inst_1 a h))) a) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))
-Case conversion may be inaccurate. Consider using '#align is_unit.coe_inv_mul IsUnit.val_inv_mulₓ'. -/
 @[simp, to_additive]
 theorem val_inv_mul (h : IsUnit a) : ↑h.Unit⁻¹ * a = 1 :=
   Units.mul_inv _
 #align is_unit.coe_inv_mul IsUnit.val_inv_mul
 #align is_add_unit.coe_neg_add IsAddUnit.val_neg_add
 
-/- warning: is_unit.mul_coe_inv -> IsUnit.mul_val_inv is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} (h : IsUnit.{u1} M _inst_1 a), Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.hasInv.{u1} M _inst_1) (IsUnit.unit.{u1} M _inst_1 a h)))) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} (h : IsUnit.{u1} M _inst_1 a), Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInv.{u1} M _inst_1) (IsUnit.unit.{u1} M _inst_1 a h)))) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_coe_inv IsUnit.mul_val_invₓ'. -/
 @[simp, to_additive]
 theorem mul_val_inv (h : IsUnit a) : a * ↑h.Unit⁻¹ = 1 := by convert h.unit.mul_inv
 #align is_unit.mul_coe_inv IsUnit.mul_val_inv
@@ -1167,12 +756,6 @@ theorem mul_val_inv (h : IsUnit a) : a * ↑h.Unit⁻¹ = 1 := by convert h.unit
 instance (x : M) [h : Decidable (∃ u : Mˣ, ↑u = x)] : Decidable (IsUnit x) :=
   h
 
-/- warning: is_unit.mul_left_inj -> IsUnit.mul_left_inj is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} {b : M} {c : M}, (IsUnit.{u1} M _inst_1 a) -> (Iff (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) b a) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) c a)) (Eq.{succ u1} M b c))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} {b : M} {c : M}, (IsUnit.{u1} M _inst_1 a) -> (Iff (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) b a) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) c a)) (Eq.{succ u1} M b c))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_left_inj IsUnit.mul_left_injₓ'. -/
 @[to_additive]
 theorem mul_left_inj (h : IsUnit a) : b * a = c * a ↔ b = c :=
   let ⟨u, hu⟩ := h
@@ -1180,12 +763,6 @@ theorem mul_left_inj (h : IsUnit a) : b * a = c * a ↔ b = c :=
 #align is_unit.mul_left_inj IsUnit.mul_left_inj
 #align is_add_unit.add_left_inj IsAddUnit.add_left_inj
 
-/- warning: is_unit.mul_right_inj -> IsUnit.mul_right_inj is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} {b : M} {c : M}, (IsUnit.{u1} M _inst_1 a) -> (Iff (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a b) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a c)) (Eq.{succ u1} M b c))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} {b : M} {c : M}, (IsUnit.{u1} M _inst_1 a) -> (Iff (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a b) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a c)) (Eq.{succ u1} M b c))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_right_inj IsUnit.mul_right_injₓ'. -/
 @[to_additive]
 theorem mul_right_inj (h : IsUnit a) : a * b = a * c ↔ b = c :=
   let ⟨u, hu⟩ := h
@@ -1193,48 +770,24 @@ theorem mul_right_inj (h : IsUnit a) : a * b = a * c ↔ b = c :=
 #align is_unit.mul_right_inj IsUnit.mul_right_inj
 #align is_add_unit.add_right_inj IsAddUnit.add_right_inj
 
-/- warning: is_unit.mul_left_cancel -> IsUnit.mul_left_cancel is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} {b : M} {c : M}, (IsUnit.{u1} M _inst_1 a) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a b) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a c)) -> (Eq.{succ u1} M b c)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} {b : M} {c : M}, (IsUnit.{u1} M _inst_1 a) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a b) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a c)) -> (Eq.{succ u1} M b c)
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_left_cancel IsUnit.mul_left_cancelₓ'. -/
 @[to_additive]
 protected theorem mul_left_cancel (h : IsUnit a) : a * b = a * c → b = c :=
   h.mul_right_inj.1
 #align is_unit.mul_left_cancel IsUnit.mul_left_cancel
 #align is_add_unit.add_left_cancel IsAddUnit.add_left_cancel
 
-/- warning: is_unit.mul_right_cancel -> IsUnit.mul_right_cancel is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} {b : M} {c : M}, (IsUnit.{u1} M _inst_1 b) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a b) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) c b)) -> (Eq.{succ u1} M a c)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} {b : M} {c : M}, (IsUnit.{u1} M _inst_1 b) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a b) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) c b)) -> (Eq.{succ u1} M a c)
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_right_cancel IsUnit.mul_right_cancelₓ'. -/
 @[to_additive]
 protected theorem mul_right_cancel (h : IsUnit b) : a * b = c * b → a = c :=
   h.mul_left_inj.1
 #align is_unit.mul_right_cancel IsUnit.mul_right_cancel
 #align is_add_unit.add_right_cancel IsAddUnit.add_right_cancel
 
-/- warning: is_unit.mul_right_injective -> IsUnit.mul_right_injective is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M ((fun (x._@.Mathlib.Algebra.Group.Units._hyg.7116 : M) (x._@.Mathlib.Algebra.Group.Units._hyg.7118 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Group.Units._hyg.7116 x._@.Mathlib.Algebra.Group.Units._hyg.7118) a))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_right_injective IsUnit.mul_right_injectiveₓ'. -/
 @[to_additive]
 protected theorem mul_right_injective (h : IsUnit a) : Injective ((· * ·) a) := fun _ _ =>
   h.mul_left_cancel
 #align is_unit.mul_right_injective IsUnit.mul_right_injective
 #align is_add_unit.add_right_injective IsAddUnit.add_right_injective
 
-/- warning: is_unit.mul_left_injective -> IsUnit.mul_left_injective is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {b : M}, (IsUnit.{u1} M _inst_1 b) -> (Function.Injective.{succ u1, succ u1} M M (fun (_x : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) _x b))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {b : M}, (IsUnit.{u1} M _inst_1 b) -> (Function.Injective.{succ u1, succ u1} M M (fun (_x : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) _x b))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_left_injective IsUnit.mul_left_injectiveₓ'. -/
 @[to_additive]
 protected theorem mul_left_injective (h : IsUnit b) : Injective (· * b) := fun _ _ =>
   h.mul_right_cancel
@@ -1245,24 +798,12 @@ end Monoid
 
 variable [DivisionMonoid M] {a : M}
 
-/- warning: is_unit.inv_mul_cancel -> IsUnit.inv_mul_cancel is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} M] {a : M}, (IsUnit.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_1)) a) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_1))))) (Inv.inv.{u1} M (DivInvMonoid.toHasInv.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_1)) a) a) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_1))))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} M] {a : M}, (IsUnit.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_1)) a) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_1))))) (Inv.inv.{u1} M (InvOneClass.toInv.{u1} M (DivInvOneMonoid.toInvOneClass.{u1} M (DivisionMonoid.toDivInvOneMonoid.{u1} M _inst_1))) a) a) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (InvOneClass.toOne.{u1} M (DivInvOneMonoid.toInvOneClass.{u1} M (DivisionMonoid.toDivInvOneMonoid.{u1} M _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align is_unit.inv_mul_cancel IsUnit.inv_mul_cancelₓ'. -/
 @[simp, to_additive]
 protected theorem inv_mul_cancel : IsUnit a → a⁻¹ * a = 1 := by rintro ⟨u, rfl⟩;
   rw [← Units.val_inv_eq_inv_val, Units.inv_mul]
 #align is_unit.inv_mul_cancel IsUnit.inv_mul_cancel
 #align is_add_unit.neg_add_cancel IsAddUnit.neg_add_cancel
 
-/- warning: is_unit.mul_inv_cancel -> IsUnit.mul_inv_cancel is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} M] {a : M}, (IsUnit.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_1)) a) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_1))))) a (Inv.inv.{u1} M (DivInvMonoid.toHasInv.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_1)) a)) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_1))))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} M] {a : M}, (IsUnit.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_1)) a) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_1))))) a (Inv.inv.{u1} M (InvOneClass.toInv.{u1} M (DivInvOneMonoid.toInvOneClass.{u1} M (DivisionMonoid.toDivInvOneMonoid.{u1} M _inst_1))) a)) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (InvOneClass.toOne.{u1} M (DivInvOneMonoid.toInvOneClass.{u1} M (DivisionMonoid.toDivInvOneMonoid.{u1} M _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_inv_cancel IsUnit.mul_inv_cancelₓ'. -/
 @[simp, to_additive]
 protected theorem mul_inv_cancel : IsUnit a → a * a⁻¹ = 1 := by rintro ⟨u, rfl⟩;
   rw [← Units.val_inv_eq_inv_val, Units.mul_inv]

bump to nightly-2023-05-28-04

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

6797a637

Diff

@@ -888,10 +888,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align mul_eq_one mul_eq_oneₓ'. -/
 @[simp, to_additive]
 theorem mul_eq_one : a * b = 1 ↔ a = 1 ∧ b = 1 :=
-  ⟨fun h => ⟨eq_one_of_mul_right h, eq_one_of_mul_left h⟩,
-    by
-    rintro ⟨rfl, rfl⟩
-    exact mul_one _⟩
+  ⟨fun h => ⟨eq_one_of_mul_right h, eq_one_of_mul_left h⟩, by rintro ⟨rfl, rfl⟩; exact mul_one _⟩
 #align mul_eq_one mul_eq_one
 #align add_eq_zero add_eq_zero
 
@@ -981,10 +978,8 @@ but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Exists.{succ u1} M (fun (b : M) => Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a b) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))))
 Case conversion may be inaccurate. Consider using '#align is_unit.exists_right_inv IsUnit.exists_right_invₓ'. -/
 @[to_additive IsAddUnit.exists_neg]
-theorem IsUnit.exists_right_inv [Monoid M] {a : M} (h : IsUnit a) : ∃ b, a * b = 1 :=
-  by
-  rcases h with ⟨⟨a, b, hab, _⟩, rfl⟩
-  exact ⟨b, hab⟩
+theorem IsUnit.exists_right_inv [Monoid M] {a : M} (h : IsUnit a) : ∃ b, a * b = 1 := by
+  rcases h with ⟨⟨a, b, hab, _⟩, rfl⟩; exact ⟨b, hab⟩
 #align is_unit.exists_right_inv IsUnit.exists_right_inv
 #align is_add_unit.exists_neg IsAddUnit.exists_neg
 
@@ -995,10 +990,8 @@ but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Exists.{succ u1} M (fun (b : M) => Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) b a) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))))
 Case conversion may be inaccurate. Consider using '#align is_unit.exists_left_inv IsUnit.exists_left_invₓ'. -/
 @[to_additive IsAddUnit.exists_neg']
-theorem IsUnit.exists_left_inv [Monoid M] {a : M} (h : IsUnit a) : ∃ b, b * a = 1 :=
-  by
-  rcases h with ⟨⟨a, b, _, hba⟩, rfl⟩
-  exact ⟨b, hba⟩
+theorem IsUnit.exists_left_inv [Monoid M] {a : M} (h : IsUnit a) : ∃ b, b * a = 1 := by
+  rcases h with ⟨⟨a, b, _, hba⟩, rfl⟩; exact ⟨b, hba⟩
 #align is_unit.exists_left_inv IsUnit.exists_left_inv
 #align is_add_unit.exists_neg' IsAddUnit.exists_neg'
 
@@ -1033,10 +1026,8 @@ but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {x : M} {y : M}, (IsUnit.{u1} M _inst_1 x) -> (IsUnit.{u1} M _inst_1 y) -> (IsUnit.{u1} M _inst_1 (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x y))
 Case conversion may be inaccurate. Consider using '#align is_unit.mul IsUnit.mulₓ'. -/
 @[to_additive]
-theorem IsUnit.mul [Monoid M] {x y : M} : IsUnit x → IsUnit y → IsUnit (x * y) :=
-  by
-  rintro ⟨x, rfl⟩ ⟨y, rfl⟩
-  exact ⟨x * y, Units.val_mul _ _⟩
+theorem IsUnit.mul [Monoid M] {x y : M} : IsUnit x → IsUnit y → IsUnit (x * y) := by
+  rintro ⟨x, rfl⟩ ⟨y, rfl⟩; exact ⟨x * y, Units.val_mul _ _⟩
 #align is_unit.mul IsUnit.mul
 #align is_add_unit.add IsAddUnit.add
 
@@ -1261,9 +1252,7 @@ but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} M] {a : M}, (IsUnit.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_1)) a) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_1))))) (Inv.inv.{u1} M (InvOneClass.toInv.{u1} M (DivInvOneMonoid.toInvOneClass.{u1} M (DivisionMonoid.toDivInvOneMonoid.{u1} M _inst_1))) a) a) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (InvOneClass.toOne.{u1} M (DivInvOneMonoid.toInvOneClass.{u1} M (DivisionMonoid.toDivInvOneMonoid.{u1} M _inst_1))))))
 Case conversion may be inaccurate. Consider using '#align is_unit.inv_mul_cancel IsUnit.inv_mul_cancelₓ'. -/
 @[simp, to_additive]
-protected theorem inv_mul_cancel : IsUnit a → a⁻¹ * a = 1 :=
-  by
-  rintro ⟨u, rfl⟩
+protected theorem inv_mul_cancel : IsUnit a → a⁻¹ * a = 1 := by rintro ⟨u, rfl⟩;
   rw [← Units.val_inv_eq_inv_val, Units.inv_mul]
 #align is_unit.inv_mul_cancel IsUnit.inv_mul_cancel
 #align is_add_unit.neg_add_cancel IsAddUnit.neg_add_cancel
@@ -1275,9 +1264,7 @@ but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} M] {a : M}, (IsUnit.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_1)) a) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_1))))) a (Inv.inv.{u1} M (InvOneClass.toInv.{u1} M (DivInvOneMonoid.toInvOneClass.{u1} M (DivisionMonoid.toDivInvOneMonoid.{u1} M _inst_1))) a)) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (InvOneClass.toOne.{u1} M (DivInvOneMonoid.toInvOneClass.{u1} M (DivisionMonoid.toDivInvOneMonoid.{u1} M _inst_1))))))
 Case conversion may be inaccurate. Consider using '#align is_unit.mul_inv_cancel IsUnit.mul_inv_cancelₓ'. -/
 @[simp, to_additive]
-protected theorem mul_inv_cancel : IsUnit a → a * a⁻¹ = 1 :=
-  by
-  rintro ⟨u, rfl⟩
+protected theorem mul_inv_cancel : IsUnit a → a * a⁻¹ = 1 := by rintro ⟨u, rfl⟩;
   rw [← Units.val_inv_eq_inv_val, Units.mul_inv]
 #align is_unit.mul_inv_cancel IsUnit.mul_inv_cancel
 #align is_add_unit.add_neg_cancel IsAddUnit.add_neg_cancel

bump to nightly-2023-05-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/33c67ae661dd8988516ff7f247b0be3018cdd952

110b734b

Diff

@@ -1230,7 +1230,7 @@ protected theorem mul_right_cancel (h : IsUnit b) : a * b = c * b → a = c :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M ((fun (x._@.Mathlib.Algebra.Group.Units._hyg.7119 : M) (x._@.Mathlib.Algebra.Group.Units._hyg.7121 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Group.Units._hyg.7119 x._@.Mathlib.Algebra.Group.Units._hyg.7121) a))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M ((fun (x._@.Mathlib.Algebra.Group.Units._hyg.7116 : M) (x._@.Mathlib.Algebra.Group.Units._hyg.7118 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Group.Units._hyg.7116 x._@.Mathlib.Algebra.Group.Units._hyg.7118) a))
 Case conversion may be inaccurate. Consider using '#align is_unit.mul_right_injective IsUnit.mul_right_injectiveₓ'. -/
 @[to_additive]
 protected theorem mul_right_injective (h : IsUnit a) : Injective ((· * ·) a) := fun _ _ =>

bump to nightly-2023-05-19-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

a31df521

Diff

@@ -1230,7 +1230,7 @@ protected theorem mul_right_cancel (h : IsUnit b) : a * b = c * b → a = c :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M ((fun (x._@.Mathlib.Algebra.Group.Units._hyg.7098 : M) (x._@.Mathlib.Algebra.Group.Units._hyg.7100 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Group.Units._hyg.7098 x._@.Mathlib.Algebra.Group.Units._hyg.7100) a))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M ((fun (x._@.Mathlib.Algebra.Group.Units._hyg.7119 : M) (x._@.Mathlib.Algebra.Group.Units._hyg.7121 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Group.Units._hyg.7119 x._@.Mathlib.Algebra.Group.Units._hyg.7121) a))
 Case conversion may be inaccurate. Consider using '#align is_unit.mul_right_injective IsUnit.mul_right_injectiveₓ'. -/
 @[to_additive]
 protected theorem mul_right_injective (h : IsUnit a) : Injective ((· * ·) a) := fun _ _ =>

bump to nightly-2023-04-25-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/2651125b48fc5c170ab1111afd0817c903b1fc6c

ed327085

Diff

@@ -180,6 +180,7 @@ Case conversion may be inaccurate. Consider using '#align units.mk_coe Units.mk_
 theorem mk_val (u : αˣ) (y h₁ h₂) : mk (u : α) y h₁ h₂ = u :=
   ext rfl
 #align units.mk_coe Units.mk_val
+#align add_units.mk_coe AddUnits.mk_val
 
 #print Units.copy /-
 /-- Copy a unit, adjusting definition equalities. -/

bump to nightly-2023-04-25-20

mathlib commit https://github.com/leanprover-community/mathlib/commit/2651125b48fc5c170ab1111afd0817c903b1fc6c

56c36841

Diff

@@ -275,7 +275,7 @@ theorem val_eq_one {a : αˣ} : (a : α) = 1 ↔ a = 1 := by rw [← Units.val_o
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (x : α) (y : α) (h₁ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) x y) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (h₂ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) y x) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))), Eq.{succ u1} (Units.{u1} α _inst_1) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) (Units.mk.{u1} α _inst_1 x y h₁ h₂)) (Units.mk.{u1} α _inst_1 y x h₂ h₁)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (x : α) (y : α) (h₁ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) x y) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (h₂ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) y x) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))), Eq.{succ u1} (Units.{u1} α _inst_1) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) (Units.mk.{u1} α _inst_1 x y h₁ h₂)) (Units.mk.{u1} α _inst_1 y x h₂ h₁)
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (x : α) (y : α) (h₁ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) x y) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (h₂ : Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) y x) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))), Eq.{succ u1} (Units.{u1} α _inst_1) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) (Units.mk.{u1} α _inst_1 x y h₁ h₂)) (Units.mk.{u1} α _inst_1 y x h₂ h₁)
 Case conversion may be inaccurate. Consider using '#align units.inv_mk Units.inv_mkₓ'. -/
 @[simp, to_additive]
 theorem inv_mk (x y : α) (h₁ h₂) : (mk x y h₁ h₂)⁻¹ = mk y x h₂ h₁ :=
@@ -307,7 +307,7 @@ theorem inv_eq_val_inv : a.inv = ((a⁻¹ : αˣ) : α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) a)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) a)) (Units.val.{u1} α _inst_1 a)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) a)) (Units.val.{u1} α _inst_1 a)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))
 Case conversion may be inaccurate. Consider using '#align units.inv_mul Units.inv_mulₓ'. -/
 @[simp, to_additive]
 theorem inv_mul : (↑a⁻¹ * a : α) = 1 :=
@@ -319,7 +319,7 @@ theorem inv_mul : (↑a⁻¹ * a : α) = 1 :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) a) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) a))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 a) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) a))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 a) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) a))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))
 Case conversion may be inaccurate. Consider using '#align units.mul_inv Units.mul_invₓ'. -/
 @[simp, to_additive]
 theorem mul_inv : (a * ↑a⁻¹ : α) = 1 :=
@@ -331,7 +331,7 @@ theorem mul_inv : (a * ↑a⁻¹ : α) = 1 :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u) a) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (Units.val.{u1} α _inst_1 u) a) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) u)) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))))
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (Units.val.{u1} α _inst_1 u) a) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align units.inv_mul_of_eq Units.inv_mul_of_eqₓ'. -/
 @[to_additive]
 theorem inv_mul_of_eq {a : α} (h : ↑u = a) : ↑u⁻¹ * a = 1 := by rw [← h, u.inv_mul]
@@ -342,7 +342,7 @@ theorem inv_mul_of_eq {a : α} (h : ↑u = a) : ↑u⁻¹ * a = 1 := by rw [←
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u) a) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (Units.val.{u1} α _inst_1 u) a) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) u))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))))
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (Units.val.{u1} α _inst_1 u) a) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align units.mul_inv_of_eq Units.mul_inv_of_eqₓ'. -/
 @[to_additive]
 theorem mul_inv_of_eq {a : α} (h : ↑u = a) : a * ↑u⁻¹ = 1 := by rw [← h, u.mul_inv]
@@ -353,7 +353,7 @@ theorem mul_inv_of_eq {a : α} (h : ↑u = a) : a * ↑u⁻¹ = 1 := by rw [←
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) (b : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) a)) b)) b
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) (b : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) a)) b)) b
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) (b : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) a)) b)) b
 Case conversion may be inaccurate. Consider using '#align units.mul_inv_cancel_left Units.mul_inv_cancel_leftₓ'. -/
 @[simp, to_additive]
 theorem mul_inv_cancel_left (a : αˣ) (b : α) : (a : α) * (↑a⁻¹ * b) = b := by
@@ -365,7 +365,7 @@ theorem mul_inv_cancel_left (a : αˣ) (b : α) : (a : α) * (↑a⁻¹ * b) = b
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) (b : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) a) b)) b
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) (b : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 a) b)) b
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) (b : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 a) b)) b
 Case conversion may be inaccurate. Consider using '#align units.inv_mul_cancel_left Units.inv_mul_cancel_leftₓ'. -/
 @[simp, to_additive]
 theorem inv_mul_cancel_left (a : αˣ) (b : α) : (↑a⁻¹ : α) * (a * b) = b := by
@@ -377,7 +377,7 @@ theorem inv_mul_cancel_left (a : αˣ) (b : α) : (↑a⁻¹ : α) * (a * b) = b
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) b)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) b))) a
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 b)) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) b))) a
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 b)) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) b))) a
 Case conversion may be inaccurate. Consider using '#align units.mul_inv_cancel_right Units.mul_inv_cancel_rightₓ'. -/
 @[simp, to_additive]
 theorem mul_inv_cancel_right (a : α) (b : αˣ) : a * b * ↑b⁻¹ = a := by
@@ -389,7 +389,7 @@ theorem mul_inv_cancel_right (a : α) (b : αˣ) : a * b * ↑b⁻¹ = a := by
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) b))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) b)) a
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) b))) (Units.val.{u1} α _inst_1 b)) a
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : Units.{u1} α _inst_1), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) b))) (Units.val.{u1} α _inst_1 b)) a
 Case conversion may be inaccurate. Consider using '#align units.inv_mul_cancel_right Units.inv_mul_cancel_rightₓ'. -/
 @[simp, to_additive]
 theorem inv_mul_cancel_right (a : α) (b : αˣ) : a * ↑b⁻¹ * b = a := by
@@ -426,7 +426,7 @@ theorem mul_left_inj (a : αˣ) {b c : α} : b * a = c * a ↔ b = c :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (c : Units.{u1} α _inst_1) {a : α} {b : α}, Iff (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) b ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) c)))) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) c)) b)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (c : Units.{u1} α _inst_1) {a : α} {b : α}, Iff (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) b (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) c)))) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 c)) b)
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (c : Units.{u1} α _inst_1) {a : α} {b : α}, Iff (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) b (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) c)))) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 c)) b)
 Case conversion may be inaccurate. Consider using '#align units.eq_mul_inv_iff_mul_eq Units.eq_mul_inv_iff_mul_eqₓ'. -/
 @[to_additive]
 theorem eq_mul_inv_iff_mul_eq {a b : α} : a = b * ↑c⁻¹ ↔ a * c = b :=
@@ -438,7 +438,7 @@ theorem eq_mul_inv_iff_mul_eq {a b : α} : a = b * ↑c⁻¹ ↔ a * c = b :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (b : Units.{u1} α _inst_1) {a : α} {c : α}, Iff (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) b)) c)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) b) a) c)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (b : Units.{u1} α _inst_1) {a : α} {c : α}, Iff (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) b)) c)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 b) a) c)
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (b : Units.{u1} α _inst_1) {a : α} {c : α}, Iff (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) b)) c)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 b) a) c)
 Case conversion may be inaccurate. Consider using '#align units.eq_inv_mul_iff_mul_eq Units.eq_inv_mul_iff_mul_eqₓ'. -/
 @[to_additive]
 theorem eq_inv_mul_iff_mul_eq {a c : α} : a = ↑b⁻¹ * c ↔ ↑b * a = c :=
@@ -450,7 +450,7 @@ theorem eq_inv_mul_iff_mul_eq {a c : α} : a = ↑b⁻¹ * c ↔ ↑b * a = c :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) {b : α} {c : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) a)) b) c) (Eq.{succ u1} α b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) a) c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) {b : α} {c : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) a)) b) c) (Eq.{succ u1} α b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 a) c))
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : Units.{u1} α _inst_1) {b : α} {c : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) a)) b) c) (Eq.{succ u1} α b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 a) c))
 Case conversion may be inaccurate. Consider using '#align units.inv_mul_eq_iff_eq_mul Units.inv_mul_eq_iff_eq_mulₓ'. -/
 @[to_additive]
 theorem inv_mul_eq_iff_eq_mul {b c : α} : ↑a⁻¹ * b = c ↔ b = a * c :=
@@ -462,7 +462,7 @@ theorem inv_mul_eq_iff_eq_mul {b c : α} : ↑a⁻¹ * b = c ↔ b = a * c :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (b : Units.{u1} α _inst_1) {a : α} {c : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) b))) c) (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) c ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) b)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (b : Units.{u1} α _inst_1) {a : α} {c : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) b))) c) (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) c (Units.val.{u1} α _inst_1 b)))
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (b : Units.{u1} α _inst_1) {a : α} {c : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) b))) c) (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) c (Units.val.{u1} α _inst_1 b)))
 Case conversion may be inaccurate. Consider using '#align units.mul_inv_eq_iff_eq_mul Units.mul_inv_eq_iff_eq_mulₓ'. -/
 @[to_additive]
 theorem mul_inv_eq_iff_eq_mul {a c : α} : a * ↑b⁻¹ = c ↔ a = c * b :=
@@ -474,7 +474,7 @@ theorem mul_inv_eq_iff_eq_mul {a c : α} : a * ↑b⁻¹ = c ↔ a = c * b :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) -> (Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 u)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) -> (Eq.{succ u1} α (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) u)) a)
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 u)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) -> (Eq.{succ u1} α (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)) a)
 Case conversion may be inaccurate. Consider using '#align units.inv_eq_of_mul_eq_one_left Units.inv_eq_of_mul_eq_one_leftₓ'. -/
 @[to_additive]
 protected theorem inv_eq_of_mul_eq_one_left {a : α} (h : a * u = 1) : ↑u⁻¹ = a :=
@@ -489,7 +489,7 @@ protected theorem inv_eq_of_mul_eq_one_left {a : α} (h : a * u = 1) : ↑u⁻¹
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) -> (Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 u) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) -> (Eq.{succ u1} α (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) u)) a)
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 u) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) -> (Eq.{succ u1} α (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)) a)
 Case conversion may be inaccurate. Consider using '#align units.inv_eq_of_mul_eq_one_right Units.inv_eq_of_mul_eq_one_rightₓ'. -/
 @[to_additive]
 protected theorem inv_eq_of_mul_eq_one_right {a : α} (h : ↑u * a = 1) : ↑u⁻¹ = a :=
@@ -504,7 +504,7 @@ protected theorem inv_eq_of_mul_eq_one_right {a : α} (h : ↑u * a = 1) : ↑u
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) -> (Eq.{succ u1} α a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 u) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) -> (Eq.{succ u1} α a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) u)))
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 u) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) -> (Eq.{succ u1} α a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)))
 Case conversion may be inaccurate. Consider using '#align units.eq_inv_of_mul_eq_one_left Units.eq_inv_of_mul_eq_one_leftₓ'. -/
 @[to_additive]
 protected theorem eq_inv_of_mul_eq_one_left {a : α} (h : ↑u * a = 1) : a = ↑u⁻¹ :=
@@ -516,7 +516,7 @@ protected theorem eq_inv_of_mul_eq_one_left {a : α} (h : ↑u * a = 1) : a = 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) -> (Eq.{succ u1} α a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 u)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) -> (Eq.{succ u1} α a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) u)))
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 u)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) -> (Eq.{succ u1} α a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)))
 Case conversion may be inaccurate. Consider using '#align units.eq_inv_of_mul_eq_one_right Units.eq_inv_of_mul_eq_one_rightₓ'. -/
 @[to_additive]
 protected theorem eq_inv_of_mul_eq_one_right {a : α} (h : a * u = 1) : a = ↑u⁻¹ :=
@@ -528,7 +528,7 @@ protected theorem eq_inv_of_mul_eq_one_right {a : α} (h : a * u = 1) : a = ↑u
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (Eq.{succ u1} α a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) u))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (Eq.{succ u1} α a (Units.val.{u1} α _inst_1 u))
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (Eq.{succ u1} α a (Units.val.{u1} α _inst_1 u))
 Case conversion may be inaccurate. Consider using '#align units.mul_inv_eq_one Units.mul_inv_eq_oneₓ'. -/
 @[simp, to_additive]
 theorem mul_inv_eq_one {a : α} : a * ↑u⁻¹ = 1 ↔ a = u :=
@@ -540,7 +540,7 @@ theorem mul_inv_eq_one {a : α} : a * ↑u⁻¹ = 1 ↔ a = u :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) u)) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (Eq.{succ u1} α (Units.val.{u1} α _inst_1 u) a)
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (Eq.{succ u1} α (Units.val.{u1} α _inst_1 u) a)
 Case conversion may be inaccurate. Consider using '#align units.inv_mul_eq_one Units.inv_mul_eq_oneₓ'. -/
 @[simp, to_additive]
 theorem inv_mul_eq_one {a : α} : ↑u⁻¹ * a = 1 ↔ ↑u = a :=
@@ -552,7 +552,7 @@ theorem inv_mul_eq_one {a : α} : ↑u⁻¹ * a = 1 ↔ ↑u = a :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (Eq.{succ u1} α a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 u)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (Eq.{succ u1} α a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) u)))
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 u)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (Eq.{succ u1} α a (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)))
 Case conversion may be inaccurate. Consider using '#align units.mul_eq_one_iff_eq_inv Units.mul_eq_one_iff_eq_invₓ'. -/
 @[to_additive]
 theorem mul_eq_one_iff_eq_inv {a : α} : a * u = 1 ↔ a = ↑u⁻¹ := by rw [← mul_inv_eq_one, inv_inv]
@@ -563,7 +563,7 @@ theorem mul_eq_one_iff_eq_inv {a : α} : a * u = 1 ↔ a = ↑u⁻¹ := by rw [
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 u) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (Eq.{succ u1} α (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) u)) a)
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {u : Units.{u1} α _inst_1} {a : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Units.val.{u1} α _inst_1 u) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (Eq.{succ u1} α (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)) a)
 Case conversion may be inaccurate. Consider using '#align units.mul_eq_one_iff_inv_eq Units.mul_eq_one_iff_inv_eqₓ'. -/
 @[to_additive]
 theorem mul_eq_one_iff_inv_eq {a : α} : ↑u * a = 1 ↔ ↑u⁻¹ = a := by rw [← inv_mul_eq_one, inv_inv]
@@ -582,7 +582,7 @@ theorem inv_unique {u₁ u₂ : αˣ} (h : (↑u₁ : α) = ↑u₂) : (↑u₁
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_2 : DivisionMonoid.{u1} M] (u : Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))), Eq.{succ u1} M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) M (coeBase.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) M (Units.hasCoe.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2)))))) (Inv.inv.{u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) (Units.hasInv.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) u)) (Inv.inv.{u1} M (DivInvMonoid.toHasInv.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) M (coeBase.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) M (Units.hasCoe.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2)))))) u))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_2 : DivisionMonoid.{u1} M] (u : Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))), Eq.{succ u1} M (Units.val.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2)) (Inv.inv.{u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) (Units.instInvUnits.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) u)) (Inv.inv.{u1} M (InvOneClass.toInv.{u1} M (DivInvOneMonoid.toInvOneClass.{u1} M (DivisionMonoid.toDivInvOneMonoid.{u1} M _inst_2))) (Units.val.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2)) u))
+  forall {M : Type.{u1}} [_inst_2 : DivisionMonoid.{u1} M] (u : Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))), Eq.{succ u1} M (Units.val.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2)) (Inv.inv.{u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) (Units.instInv.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2))) u)) (Inv.inv.{u1} M (InvOneClass.toInv.{u1} M (DivInvOneMonoid.toInvOneClass.{u1} M (DivisionMonoid.toDivInvOneMonoid.{u1} M _inst_2))) (Units.val.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_2)) u))
 Case conversion may be inaccurate. Consider using '#align units.coe_inv Units.val_inv_eq_inv_valₓ'. -/
 @[simp, to_additive]
 theorem val_inv_eq_inv_val {M : Type _} [DivisionMonoid M] (u : Units M) : ↑u⁻¹ = (u⁻¹ : M) :=
@@ -683,7 +683,7 @@ theorem divp_assoc' (x y : α) (u : αˣ) : x * (y /ₚ u) = x * y /ₚ u :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} (u : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 a (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) u))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} (u : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 a (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) u)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 u))
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} (u : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 a (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (Units.val.{u1} α _inst_1 u))
 Case conversion may be inaccurate. Consider using '#align divp_inv divp_invₓ'. -/
 @[simp]
 theorem divp_inv (u : αˣ) : a /ₚ u⁻¹ = a * u :=
@@ -766,7 +766,7 @@ theorem divp_eq_one_iff_eq {a : α} {u : αˣ} : a /ₚ u = 1 ↔ a = u :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))))) u) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))) u) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) u))
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1), Eq.{succ u1} α (divp.{u1} α _inst_1 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))) u) (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u))
 Case conversion may be inaccurate. Consider using '#align one_divp one_divpₓ'. -/
 @[simp]
 theorem one_divp (u : αˣ) : 1 /ₚ u = ↑u⁻¹ :=
@@ -777,7 +777,7 @@ theorem one_divp (u : αˣ) : 1 /ₚ u = ↑u⁻¹ :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1), Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α _inst_1) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α _inst_1) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α _inst_1) α (coeBase.{succ u1, succ u1} (Units.{u1} α _inst_1) α (Units.hasCoe.{u1} α _inst_1)))) (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.hasInv.{u1} α _inst_1) u)) (divp.{u1} α _inst_1 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))))) u)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1), Eq.{succ u1} α (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInvUnits.{u1} α _inst_1) u)) (divp.{u1} α _inst_1 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))) u)
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1), Eq.{succ u1} α (Units.val.{u1} α _inst_1 (Inv.inv.{u1} (Units.{u1} α _inst_1) (Units.instInv.{u1} α _inst_1) u)) (divp.{u1} α _inst_1 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))) u)
 Case conversion may be inaccurate. Consider using '#align inv_eq_one_divp inv_eq_one_divpₓ'. -/
 /-- Used for `field_simp` to deal with inverses of units. -/
 @[field_simps]
@@ -1151,7 +1151,7 @@ theorem unit_spec (h : IsUnit a) : ↑h.Unit = a :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} (h : IsUnit.{u1} M _inst_1 a), Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.hasInv.{u1} M _inst_1) (IsUnit.unit.{u1} M _inst_1 a h))) a) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} (h : IsUnit.{u1} M _inst_1 a), Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInvUnits.{u1} M _inst_1) (IsUnit.unit.{u1} M _inst_1 a h))) a) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} (h : IsUnit.{u1} M _inst_1 a), Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInv.{u1} M _inst_1) (IsUnit.unit.{u1} M _inst_1 a h))) a) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))
 Case conversion may be inaccurate. Consider using '#align is_unit.coe_inv_mul IsUnit.val_inv_mulₓ'. -/
 @[simp, to_additive]
 theorem val_inv_mul (h : IsUnit a) : ↑h.Unit⁻¹ * a = 1 :=
@@ -1163,7 +1163,7 @@ theorem val_inv_mul (h : IsUnit a) : ↑h.Unit⁻¹ * a = 1 :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} (h : IsUnit.{u1} M _inst_1 a), Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.hasInv.{u1} M _inst_1) (IsUnit.unit.{u1} M _inst_1 a h)))) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} (h : IsUnit.{u1} M _inst_1 a), Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInvUnits.{u1} M _inst_1) (IsUnit.unit.{u1} M _inst_1 a h)))) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M} (h : IsUnit.{u1} M _inst_1 a), Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInv.{u1} M _inst_1) (IsUnit.unit.{u1} M _inst_1 a h)))) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))
 Case conversion may be inaccurate. Consider using '#align is_unit.mul_coe_inv IsUnit.mul_val_invₓ'. -/
 @[simp, to_additive]
 theorem mul_val_inv (h : IsUnit a) : a * ↑h.Unit⁻¹ = 1 := by convert h.unit.mul_inv

bump to nightly-2023-04-11-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/c9236f47f5b9df573443aa499c0d3968769628b7

0ff24cd7

Diff

@@ -855,18 +855,36 @@ theorem divp_mul_divp (x y : α) (ux uy : αˣ) : x /ₚ ux * (y /ₚ uy) = x *
 
 variable [Subsingleton αˣ] {a b : α}
 
+/- warning: eq_one_of_mul_right -> eq_one_of_mul_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : Subsingleton.{succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))] {a : α} {b : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))) -> (Eq.{succ u1} α a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : Subsingleton.{succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))] {a : α} {b : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))) -> (Eq.{succ u1} α a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))
+Case conversion may be inaccurate. Consider using '#align eq_one_of_mul_right eq_one_of_mul_rightₓ'. -/
 @[to_additive]
 theorem eq_one_of_mul_right (h : a * b = 1) : a = 1 :=
   congr_arg Units.inv <| Subsingleton.elim (Units.mk _ _ (by rwa [mul_comm]) h) 1
 #align eq_one_of_mul_right eq_one_of_mul_right
 #align eq_zero_of_add_right eq_zero_of_add_right
 
+/- warning: eq_one_of_mul_left -> eq_one_of_mul_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : Subsingleton.{succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))] {a : α} {b : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))) -> (Eq.{succ u1} α b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : Subsingleton.{succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))] {a : α} {b : α}, (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))) -> (Eq.{succ u1} α b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))
+Case conversion may be inaccurate. Consider using '#align eq_one_of_mul_left eq_one_of_mul_leftₓ'. -/
 @[to_additive]
 theorem eq_one_of_mul_left (h : a * b = 1) : b = 1 :=
   congr_arg Units.inv <| Subsingleton.elim (Units.mk _ _ h <| by rwa [mul_comm]) 1
 #align eq_one_of_mul_left eq_one_of_mul_left
 #align eq_zero_of_add_left eq_zero_of_add_left
 
+/- warning: mul_eq_one -> mul_eq_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : Subsingleton.{succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))] {a : α} {b : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))) (And (Eq.{succ u1} α a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))) (Eq.{succ u1} α b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : Subsingleton.{succ u1} (Units.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))] {a : α} {b : α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))) (And (Eq.{succ u1} α a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))) (Eq.{succ u1} α b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))
+Case conversion may be inaccurate. Consider using '#align mul_eq_one mul_eq_oneₓ'. -/
 @[simp, to_additive]
 theorem mul_eq_one : a * b = 1 ↔ a = 1 ∧ b = 1 :=
   ⟨fun h => ⟨eq_one_of_mul_right h, eq_one_of_mul_left h⟩,
@@ -1211,7 +1229,7 @@ protected theorem mul_right_cancel (h : IsUnit b) : a * b = c * b → a = c :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M ((fun (x._@.Mathlib.Algebra.Group.Units._hyg.6867 : M) (x._@.Mathlib.Algebra.Group.Units._hyg.6869 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Group.Units._hyg.6867 x._@.Mathlib.Algebra.Group.Units._hyg.6869) a))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M ((fun (x._@.Mathlib.Algebra.Group.Units._hyg.7098 : M) (x._@.Mathlib.Algebra.Group.Units._hyg.7100 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Group.Units._hyg.7098 x._@.Mathlib.Algebra.Group.Units._hyg.7100) a))
 Case conversion may be inaccurate. Consider using '#align is_unit.mul_right_injective IsUnit.mul_right_injectiveₓ'. -/
 @[to_additive]
 protected theorem mul_right_injective (h : IsUnit a) : Injective ((· * ·) a) := fun _ _ =>

bump to nightly-2023-04-06-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/06a655b5fcfbda03502f9158bbf6c0f1400886f9

89485060

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau, Mario Carneiro, Johannes Hölzl, Chris Hughes, Jens Wagemaker, Jon Eugster
 
 ! This file was ported from Lean 3 source module algebra.group.units
-! leanprover-community/mathlib commit 369525b73f229ccd76a6ec0e0e0bf2be57599768
+! leanprover-community/mathlib commit e8638a0fcaf73e4500469f368ef9494e495099b3
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -853,6 +853,29 @@ theorem divp_mul_divp (x y : α) (ux uy : αˣ) : x /ₚ ux * (y /ₚ uy) = x *
   rw [divp_mul_eq_mul_divp, divp_assoc', divp_divp_eq_divp_mul]
 #align divp_mul_divp divp_mul_divp
 
+variable [Subsingleton αˣ] {a b : α}
+
+@[to_additive]
+theorem eq_one_of_mul_right (h : a * b = 1) : a = 1 :=
+  congr_arg Units.inv <| Subsingleton.elim (Units.mk _ _ (by rwa [mul_comm]) h) 1
+#align eq_one_of_mul_right eq_one_of_mul_right
+#align eq_zero_of_add_right eq_zero_of_add_right
+
+@[to_additive]
+theorem eq_one_of_mul_left (h : a * b = 1) : b = 1 :=
+  congr_arg Units.inv <| Subsingleton.elim (Units.mk _ _ h <| by rwa [mul_comm]) 1
+#align eq_one_of_mul_left eq_one_of_mul_left
+#align eq_zero_of_add_left eq_zero_of_add_left
+
+@[simp, to_additive]
+theorem mul_eq_one : a * b = 1 ↔ a = 1 ∧ b = 1 :=
+  ⟨fun h => ⟨eq_one_of_mul_right h, eq_one_of_mul_left h⟩,
+    by
+    rintro ⟨rfl, rfl⟩
+    exact mul_one _⟩
+#align mul_eq_one mul_eq_one
+#align add_eq_zero add_eq_zero
+
 end CommMonoid
 
 /-!

bump to nightly-2023-03-08-00

mathlib commit https://github.com/leanprover-community/mathlib/commit/3b267e70a936eebb21ab546f49a8df34dd300b25

101eaa63

Diff

@@ -1188,7 +1188,7 @@ protected theorem mul_right_cancel (h : IsUnit b) : a * b = c * b → a = c :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M ((fun (x._@.Mathlib.Algebra.Group.Units._hyg.6882 : M) (x._@.Mathlib.Algebra.Group.Units._hyg.6884 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Group.Units._hyg.6882 x._@.Mathlib.Algebra.Group.Units._hyg.6884) a))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M ((fun (x._@.Mathlib.Algebra.Group.Units._hyg.6867 : M) (x._@.Mathlib.Algebra.Group.Units._hyg.6869 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Group.Units._hyg.6867 x._@.Mathlib.Algebra.Group.Units._hyg.6869) a))
 Case conversion may be inaccurate. Consider using '#align is_unit.mul_right_injective IsUnit.mul_right_injectiveₓ'. -/
 @[to_additive]
 protected theorem mul_right_injective (h : IsUnit a) : Injective ((· * ·) a) := fun _ _ =>

bump to nightly-2023-03-01-00

mathlib commit https://github.com/leanprover-community/mathlib/commit/9da1b3534b65d9661eb8f42443598a92bbb49211

bccc50cf

Diff

@@ -125,9 +125,9 @@ def [anonymous] (u : αˣ) : α :=
   ↑u⁻¹
 #align units.simps.coe_inv [anonymous]
 
-initialize_simps_projections Units (val → coe as_prefix, inv → coe_inv as_prefix)
+initialize_simps_projections Units (val → coe, as_prefix coe, inv → coe_inv, as_prefix coe_inv)
 
-initialize_simps_projections AddUnits (val → coe as_prefix, neg → coe_neg as_prefix)
+initialize_simps_projections AddUnits (val → coe, as_prefix coe, neg → coe_neg, as_prefix coe_neg)
 
 /- warning: units.coe_mk -> Units.val_mk is a dubious translation:
 lean 3 declaration is

bump to nightly-2023-02-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

1107b979

Changes in mathlib4

mathlib3

mathlib4

chore: unify date formatting in lemma deprecations (#12334)

consistently use the YYYY-MM-DD format
when easily possible, put the date on the same line as the deprecated attribute
when easily possible, format the entire declaration on the same line

Why these changes?

consistency makes it easier for tools to parse this information
compactness: I don't see a good reason for these declarations taking up more space than needed; as I understand it, deprecated lemmas are not supposed to be used in mathlib anyway
putting the date on the same line as the attribute makes it easier to discover un-dated deprecations; they also ease writing a tool to replace these by a machine-readable version using leanprover/lean4#3968

7e72dffd

Diff

@@ -1214,7 +1214,7 @@ noncomputable def commGroupOfIsUnit [hM : CommMonoid M] (h : ∀ a : M, IsUnit a
 
 end NoncomputableDefs
 
--- 2024--03-20
+-- 2024-03-20
 attribute [deprecated div_mul_cancel_right] IsUnit.div_mul_left
 attribute [deprecated sub_add_cancel_right] IsAddUnit.sub_add_left
 attribute [deprecated div_mul_cancel_left] IsUnit.div_mul_right

perf(Group.Units): factor out data fields (#11332)

We factor out data fields to avoid unecessary unfolding.

Co-authored-by: Matthew Robert Ballard <100034030+mattrobball@users.noreply.github.com>

588c277e

Diff

@@ -187,14 +187,22 @@ theorem copy_eq (u : αˣ) (val hv inv hi) : u.copy val hv inv hi = u :=
 #align units.copy_eq Units.copy_eq
 #align add_units.copy_eq AddUnits.copy_eq
 
-/-- Units of a monoid form have a multiplication and multiplicative identity. -/
-@[to_additive "Additive units of an additive monoid have an addition and an additive identity."]
-instance instMulOneClass : MulOneClass αˣ where
+/-- Units of a monoid have an induced multiplication. -/
+@[to_additive "Additive units of an additive monoid have an induced addition."]
+instance : Mul αˣ where
   mul u₁ u₂ :=
     ⟨u₁.val * u₂.val, u₂.inv * u₁.inv,
       by rw [mul_assoc, ← mul_assoc u₂.val, val_inv, one_mul, val_inv],
       by rw [mul_assoc, ← mul_assoc u₁.inv, inv_val, one_mul, inv_val]⟩
+
+/-- Units of a monoid have a unit -/
+@[to_additive "Additive units of an additive monoid have a zero."]
+instance : One αˣ where
   one := ⟨1, 1, one_mul 1, one_mul 1⟩
+
+/-- Units of a monoid have a multiplication and multiplicative identity. -/
+@[to_additive "Additive units of an additive monoid have an addition and an additive identity."]
+instance instMulOneClass : MulOneClass αˣ where
   one_mul u := ext <| one_mul (u : α)
   mul_one u := ext <| mul_one (u : α)
 
@@ -203,7 +211,6 @@ instance instMulOneClass : MulOneClass αˣ where
 instance : Inhabited αˣ :=
   ⟨1⟩
 
-
 /-- Units of a monoid have a representation of the base value in the `Monoid`. -/
 @[to_additive "Additive units of an additive monoid have a representation of the base value in
 the `AddMonoid`."]
@@ -378,23 +385,29 @@ instance instMonoid : Monoid αˣ :=
     npow_zero := fun a ↦ by ext; simp
     npow_succ := fun n a ↦ by ext; simp [pow_succ] }
 
+/-- Units of a monoid have division -/
+@[to_additive "Additive units of an additive monoid have subtraction."]
+instance : Div αˣ where
+  div := fun a b ↦
+    { val := a * b⁻¹
+      inv := b * a⁻¹
+      val_inv := by rw [mul_assoc, inv_mul_cancel_left, mul_inv]
+      inv_val := by rw [mul_assoc, inv_mul_cancel_left, mul_inv] }
+
+/-- Units of a monoid form a `DivInvMonoid`. -/
+@[to_additive "Additive units of an additive monoid form a `SubNegMonoid`."]
+instance instDivInvMonoid : DivInvMonoid αˣ where
+  zpow := fun n a ↦ match n, a with
+    | Int.ofNat n, a => a ^ n
+    | Int.negSucc n, a => (a ^ n.succ)⁻¹
+  zpow_zero' := fun a ↦ by simp
+  zpow_succ' := fun n a ↦ by simp [pow_succ]
+  zpow_neg' := fun n a ↦ by simp
+
 /-- Units of a monoid form a group. -/
 @[to_additive "Additive units of an additive monoid form an additive group."]
-instance instGroup : Group αˣ :=
-  { (inferInstance : Monoid αˣ) with
-    inv := Inv.inv
-    mul_left_inv := fun u => ext u.inv_val
-    div := fun a b ↦
-      { val := a * b⁻¹
-        inv := b * a⁻¹
-        val_inv := by rw [mul_assoc, inv_mul_cancel_left, mul_inv]
-        inv_val := by rw [mul_assoc, inv_mul_cancel_left, mul_inv] }
-    zpow := fun n a ↦ match n, a with
-      | Int.ofNat n, a => a ^ n
-      | Int.negSucc n, a => (a ^ n.succ)⁻¹
-    zpow_zero' := fun a ↦ by simp
-    zpow_succ' := fun n a ↦ by simp [pow_succ]
-    zpow_neg' := fun n a ↦ by simp }
+instance instGroup : Group αˣ where
+  mul_left_inv := fun u => ext u.inv_val
 
 /-- Units of a commutative monoid form a commutative group. -/
 @[to_additive "Additive units of an additive commutative monoid form
@@ -667,10 +680,8 @@ instance [Monoid M] : CanLift M Mˣ Units.val IsUnit :=
 /-- A subsingleton `Monoid` has a unique unit. -/
 @[to_additive "A subsingleton `AddMonoid` has a unique additive unit."]
 instance [Monoid M] [Subsingleton M] : Unique Mˣ where
-  default := 1
   uniq a := Units.val_eq_one.mp <| Subsingleton.elim (a : M) 1
 
-
 @[to_additive (attr := simp)]
 protected theorem Units.isUnit [Monoid M] (u : Mˣ) : IsUnit (u : M) :=
   ⟨u, rfl⟩
@@ -1179,10 +1190,14 @@ section NoncomputableDefs
 
 variable {M : Type*}
 
+/-- Constructs an inv operation for a `Monoid` consisting only of units. -/
+noncomputable def invOfIsUnit [Monoid M] (h : ∀ a : M, IsUnit a) : Inv M where
+  inv := fun a => ↑(h a).unit⁻¹
+
 /-- Constructs a `Group` structure on a `Monoid` consisting only of units. -/
 noncomputable def groupOfIsUnit [hM : Monoid M] (h : ∀ a : M, IsUnit a) : Group M :=
   { hM with
-    inv := fun a => ↑(h a).unit⁻¹,
+    toInv := invOfIsUnit h,
     mul_left_inv := fun a => by
       change ↑(h a).unit⁻¹ * a = 1
       rw [Units.inv_mul_eq_iff_eq_mul, (h a).unit_spec, mul_one] }
@@ -1191,7 +1206,7 @@ noncomputable def groupOfIsUnit [hM : Monoid M] (h : ∀ a : M, IsUnit a) : Grou
 /-- Constructs a `CommGroup` structure on a `CommMonoid` consisting only of units. -/
 noncomputable def commGroupOfIsUnit [hM : CommMonoid M] (h : ∀ a : M, IsUnit a) : CommGroup M :=
   { hM with
-    inv := fun a => ↑(h a).unit⁻¹,
+    toInv := invOfIsUnit h,
     mul_left_inv := fun a => by
       change ↑(h a).unit⁻¹ * a = 1
       rw [Units.inv_mul_eq_iff_eq_mul, (h a).unit_spec, mul_one] }

style: remove redundant instance arguments (#11581)

I removed some redundant instance arguments throughout Mathlib. To do this, I used VS Code's regex search. See https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/repeating.20instances.20from.20variable.20command I closed the previous PR for this and reopened it.

acda20c6

Diff

@@ -705,7 +705,7 @@ lemma IsUnit.exists_right_inv (h : IsUnit a) : ∃ b, a * b = 1 := by
 #align is_add_unit.exists_neg IsAddUnit.exists_neg
 
 @[to_additive IsAddUnit.exists_neg']
-lemma IsUnit.exists_left_inv [Monoid M] {a : M} (h : IsUnit a) : ∃ b, b * a = 1 := by
+lemma IsUnit.exists_left_inv {a : M} (h : IsUnit a) : ∃ b, b * a = 1 := by
   rcases h with ⟨⟨a, b, _, hba⟩, rfl⟩
   exact ⟨b, hba⟩
 #align is_unit.exists_left_inv IsUnit.exists_left_inv

chore: Rename mul-div cancellation lemmas (#11530)

Lemma names around cancellation of multiplication and division are a mess.

This PR renames a handful of them according to the following table (each big row contains the multiplicative statement, then the three rows contain the GroupWithZero lemma name, the Group lemma, the AddGroup lemma name).

4ea4a86a

Diff

@@ -1012,10 +1012,10 @@ protected lemma div_mul_cancel (h : IsUnit b) (a : α) : a / b * b = a := by
 #align is_add_unit.sub_add_cancel IsAddUnit.sub_add_cancel
 
 @[to_additive (attr := simp)]
-protected lemma mul_div_cancel (h : IsUnit b) (a : α) : a * b / b = a := by
+protected lemma mul_div_cancel_right (h : IsUnit b) (a : α) : a * b / b = a := by
   rw [div_eq_mul_inv, h.mul_inv_cancel_right]
-#align is_unit.mul_div_cancel IsUnit.mul_div_cancel
-#align is_add_unit.add_sub_cancel IsAddUnit.add_sub_cancel
+#align is_unit.mul_div_cancel mul_div_cancel_right
+#align is_add_unit.add_sub_cancel add_sub_cancel_right
 
 @[to_additive]
 protected lemma mul_one_div_cancel (h : IsUnit a) : a * (1 / a) = 1 := by simp [h]
@@ -1077,10 +1077,13 @@ protected lemma div_eq_one_iff_eq (h : IsUnit b) : a / b = 1 ↔ a = b :=
 #align is_unit.div_eq_one_iff_eq IsUnit.div_eq_one_iff_eq
 #align is_add_unit.sub_eq_zero_iff_eq IsAddUnit.sub_eq_zero_iff_eq
 
-/-- The `Group` version of this lemma is `div_mul_cancel'''` -/
-@[to_additive "The `AddGroup` version of this lemma is `sub_add_cancel''`"]
+@[to_additive]
+protected lemma div_mul_cancel_right (h : IsUnit b) (a : α) : b / (a * b) = a⁻¹ := by
+  rw [div_eq_mul_inv, mul_inv_rev, h.mul_inv_cancel_left]
+
+@[to_additive]
 protected lemma div_mul_left (h : IsUnit b) : b / (a * b) = 1 / a := by
-  rw [div_eq_mul_inv, mul_inv_rev, h.mul_inv_cancel_left, one_div]
+  rw [h.div_mul_cancel_right, one_div]
 #align is_unit.div_mul_left IsUnit.div_mul_left
 #align is_add_unit.sub_add_left IsAddUnit.sub_add_left
 
@@ -1100,6 +1103,10 @@ end DivisionMonoid
 section DivisionCommMonoid
 variable [DivisionCommMonoid α] {a b c d : α}
 
+@[to_additive]
+protected lemma div_mul_cancel_left (h : IsUnit a) (b : α) : a / (a * b) = b⁻¹ := by
+  rw [mul_comm, h.div_mul_cancel_right]
+
 @[to_additive]
 protected lemma div_mul_right (h : IsUnit a) (b : α) : a / (a * b) = 1 / b := by
   rw [mul_comm, h.div_mul_left]
@@ -1108,15 +1115,15 @@ protected lemma div_mul_right (h : IsUnit a) (b : α) : a / (a * b) = 1 / b := b
 
 @[to_additive]
 protected lemma mul_div_cancel_left (h : IsUnit a) (b : α) : a * b / a = b := by
-  rw [mul_comm, h.mul_div_cancel]
-#align is_unit.mul_div_cancel_left IsUnit.mul_div_cancel_left
-#align is_add_unit.add_sub_cancel_left IsAddUnit.add_sub_cancel_left
+  rw [mul_comm, h.mul_div_cancel_right]
+#align is_unit.mul_div_cancel_left mul_div_cancel_left
+#align is_add_unit.add_sub_cancel_left add_sub_cancel_left
 
 @[to_additive]
-protected lemma mul_div_cancel' (h : IsUnit a) (b : α) : a * (b / a) = b := by
+protected lemma mul_div_cancel (h : IsUnit a) (b : α) : a * (b / a) = b := by
   rw [mul_comm, h.div_mul_cancel]
-#align is_unit.mul_div_cancel' IsUnit.mul_div_cancel'
-#align is_add_unit.add_sub_cancel' IsAddUnit.add_sub_cancel'
+#align is_unit.mul_div_cancel' IsUnit.mul_div_cancel
+#align is_add_unit.add_sub_cancel' IsAddUnit.add_sub_cancel
 
 @[to_additive]
 protected lemma mul_div_mul_left (h : IsUnit c) (a b : α) : c * a / (c * b) = a / b := by
@@ -1191,3 +1198,14 @@ noncomputable def commGroupOfIsUnit [hM : CommMonoid M] (h : ∀ a : M, IsUnit a
 #align comm_group_of_is_unit commGroupOfIsUnit
 
 end NoncomputableDefs
+
+-- 2024--03-20
+attribute [deprecated div_mul_cancel_right] IsUnit.div_mul_left
+attribute [deprecated sub_add_cancel_right] IsAddUnit.sub_add_left
+attribute [deprecated div_mul_cancel_left] IsUnit.div_mul_right
+attribute [deprecated sub_add_cancel_left] IsAddUnit.sub_add_right
+-- The names `IsUnit.mul_div_cancel` and `IsAddUnit.add_sub_cancel` have been reused
+-- @[deprecated] alias IsUnit.mul_div_cancel := IsUnit.mul_div_cancel_right
+-- @[deprecated] alias IsAddUnit.add_sub_cancel := IsAddUnit.add_sub_cancel_right
+@[deprecated] alias IsUnit.mul_div_cancel' := IsUnit.mul_div_cancel
+@[deprecated] alias IsAddUnit.add_sub_cancel' := IsAddUnit.add_sub_cancel

chore: classify todo porting notes (#11216)

Classifies by adding issue number #11215 to porting notes claiming "TODO".

86f95a40

Diff

@@ -923,7 +923,7 @@ def unit' (h : IsUnit a) : αˣ := ⟨a, a⁻¹, h.mul_inv_cancel, h.inv_mul_can
 #align is_unit.coe_unit' IsUnit.val_unit'
 #align is_add_unit.coe_add_unit' IsAddUnit.val_addUnit'
 
--- Porting note: TODO: `simps val_inv` fails
+-- Porting note (#11215): TODO: `simps val_inv` fails
 @[to_additive] lemma val_inv_unit' (h : IsUnit a) : ↑(h.unit'⁻¹) = a⁻¹ := rfl
 #align is_unit.coe_inv_unit' IsUnit.val_inv_unit'
 #align is_add_unit.coe_neg_add_unit' IsAddUnit.val_neg_addUnit'

style: fix typos in porting notes (#10931)

8db59278

Diff

@@ -528,7 +528,7 @@ theorem divp_divp_eq_divp_mul (x : α) (u₁ u₂ : αˣ) : x /ₚ u₁ /ₚ u
   simp only [divp, mul_inv_rev, Units.val_mul, mul_assoc]
 #align divp_divp_eq_divp_mul divp_divp_eq_divp_mul
 
-/- Port note: to match the mathlib3 behavior, this needs to have higher simp
+/- Porting note: to match the mathlib3 behavior, this needs to have higher simp
 priority than eq_divp_iff_mul_eq. -/
 @[field_simps 1010]
 theorem divp_eq_iff_mul_eq {x : α} {u : αˣ} {y : α} : x /ₚ u = y ↔ y * u = x :=

feat: IsUnit if exists both inverses (#10719)

Added one theorem

Co-authored-by: Xavier Xarles <56635243+XavierXarles@users.noreply.github.com> Co-authored-by: adomani <adomani@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

73c76f61

Diff

@@ -639,12 +639,21 @@ def IsUnit [Monoid M] (a : M) : Prop :=
 #align is_unit IsUnit
 #align is_add_unit IsAddUnit
 
-@[to_additive]
+/-- See `isUnit_iff_exists_and_exists` for a similar lemma with two existentials. -/
+@[to_additive "See `isAddUnit_iff_exists_and_exists` for a similar lemma with two existentials."]
 lemma isUnit_iff_exists [Monoid M] {x : M} : IsUnit x ↔ ∃ b, x * b = 1 ∧ b * x = 1 := by
   refine ⟨fun ⟨u, hu⟩ => ?_, fun ⟨b, h1b, h2b⟩ => ⟨⟨x, b, h1b, h2b⟩, rfl⟩⟩
   subst x
   exact ⟨u.inv, u.val_inv, u.inv_val⟩
 
+/-- See `isUnit_iff_exists` for a similar lemma with one existential. -/
+@[to_additive "See `isAddUnit_iff_exists` for a similar lemma with one existential."]
+theorem isUnit_iff_exists_and_exists [Monoid M] {a : M} :
+    IsUnit a ↔ (∃ b, a * b = 1) ∧ (∃ c, c * a = 1) :=
+  isUnit_iff_exists.trans
+    ⟨fun ⟨b, hba, hab⟩ => ⟨⟨b, hba⟩, ⟨b, hab⟩⟩,
+      fun ⟨⟨b, hb⟩, ⟨_, hc⟩⟩ => ⟨b, hb, left_inv_eq_right_inv hc hb ▸ hc⟩⟩
+
 @[to_additive (attr := nontriviality)]
 theorem isUnit_of_subsingleton [Monoid M] [Subsingleton M] (a : M) : IsUnit a :=
   ⟨⟨a, a, Subsingleton.elim _ _, Subsingleton.elim _ _⟩, rfl⟩

feat: cyclic group lemmas (#10832)

Add a lemma stating that non-identity element of a finite group of prime order generates the group (stated in 4 ways)
Use this to golf isCyclic_of_prime_card
Add a version of isUnit_iff_exists_inv for non-commutative monoids.

563fbc18

Diff

@@ -639,6 +639,12 @@ def IsUnit [Monoid M] (a : M) : Prop :=
 #align is_unit IsUnit
 #align is_add_unit IsAddUnit
 
+@[to_additive]
+lemma isUnit_iff_exists [Monoid M] {x : M} : IsUnit x ↔ ∃ b, x * b = 1 ∧ b * x = 1 := by
+  refine ⟨fun ⟨u, hu⟩ => ?_, fun ⟨b, h1b, h2b⟩ => ⟨⟨x, b, h1b, h2b⟩, rfl⟩⟩
+  subst x
+  exact ⟨u.inv, u.val_inv, u.inv_val⟩
+
 @[to_additive (attr := nontriviality)]
 theorem isUnit_of_subsingleton [Monoid M] [Subsingleton M] (a : M) : IsUnit a :=
   ⟨⟨a, a, Subsingleton.elim _ _, Subsingleton.elim _ _⟩, rfl⟩

feat: add proof of Jordan-Chevalley-Dunford decomposition (#10295)

8857f4e2

Diff

@@ -674,6 +674,11 @@ theorem isUnit_of_mul_eq_one [CommMonoid M] (a b : M) (h : a * b = 1) : IsUnit a
 #align is_unit_of_mul_eq_one isUnit_of_mul_eq_one
 #align is_add_unit_of_add_eq_zero isAddUnit_of_add_eq_zero
 
+@[to_additive]
+theorem isUnit_of_mul_eq_one_right [CommMonoid M] (a b : M) (h : a * b = 1) : IsUnit b := by
+  rw [mul_comm] at h
+  exact isUnit_of_mul_eq_one b a h
+
 section Monoid
 variable [Monoid M] {a b : M}

chore: reduce imports (#9830)

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

f4c4ca61

Diff

@@ -8,7 +8,6 @@ import Mathlib.Algebra.GroupPower.Basic
 import Mathlib.Logic.Unique
 import Mathlib.Tactic.Nontriviality
 import Mathlib.Tactic.Lift
-import Mathlib.Tactic.Nontriviality
 
 #align_import algebra.group.units from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"

feat: isUnit_iff_eq_one (#9706)

From flt-regular.

Also move the related units_eq_one nearby.

65ced9a7

Diff

@@ -702,6 +702,13 @@ lemma IsUnit.exists_left_inv [Monoid M] {a : M} (h : IsUnit a) : ∃ b, b * a =
 #align is_unit.pow IsUnit.pow
 #align is_add_unit.nsmul IsAddUnit.nsmul
 
+theorem units_eq_one [Unique Mˣ] (u : Mˣ) : u = 1 :=
+  Subsingleton.elim u 1
+#align units_eq_one units_eq_one
+
+@[to_additive] lemma isUnit_iff_eq_one [Unique Mˣ] {x : M} : IsUnit x ↔ x = 1 :=
+  ⟨fun ⟨u, hu⟩ ↦ by rw [← hu, Subsingleton.elim u 1, Units.val_one], fun h ↦ h ▸ isUnit_one⟩
+
 end Monoid
 
 @[to_additive]

feat: Add Basis.of_isLocalizedModule (#9210)

Let Mₛ be a R-module and let M be a submodule of Mₛ such that Mₛ is the localization at S of M where S is a submonoid of R. Assume that Mₛ is a Rₛ-module where Rₛ is a localization of R at S. Then, any R-basis of M is a Rₛ-basis of Mₛ.

This result is used to prove the results about Basis.localizationLocalization. For that, it is necessary to move some results between files and modify some imports.

Co-authored-by: Junyan Xu <junyanxumath@gmail.com>

Co-authored-by: Junyan Xu <junyanxu.math@gmail.com>

33ffe521

Diff

@@ -850,6 +850,20 @@ protected theorem mul_left_injective (h : IsUnit b) : Injective (· * b) :=
 #align is_unit.mul_left_injective IsUnit.mul_left_injective
 #align is_add_unit.add_left_injective IsAddUnit.add_left_injective
 
+@[to_additive]
+theorem isUnit_iff_mulLeft_bijective {a : M} :
+    IsUnit a ↔ Function.Bijective (a * ·) :=
+  ⟨fun h ↦ ⟨h.mul_right_injective, fun y ↦ ⟨h.unit⁻¹ * y, by simp [← mul_assoc]⟩⟩, fun h ↦
+    ⟨⟨a, _, (h.2 1).choose_spec, h.1
+      (by simpa [mul_assoc] using congr_arg (· * a) (h.2 1).choose_spec)⟩, rfl⟩⟩
+
+@[to_additive]
+theorem isUnit_iff_mulRight_bijective {a : M} :
+    IsUnit a ↔ Function.Bijective (· * a) :=
+  ⟨fun h ↦ ⟨h.mul_left_injective, fun y ↦ ⟨y * h.unit⁻¹, by simp [mul_assoc]⟩⟩,
+    fun h ↦ ⟨⟨a, _, h.1 (by simpa [mul_assoc] using congr_arg (a * ·) (h.2 1).choose_spec),
+      (h.2 1).choose_spec⟩, rfl⟩⟩
+
 end Monoid
 
 section DivisionMonoid

feat: a / b = c / d ↔ a * d = c * b when b, d commute (#9389)

This involves moving a bunch of lemmas from Algebra.Group.Units.Hom to Algebra.Group.Units (without modification).

From LeanAPAP

7ab8c781

Diff

@@ -8,6 +8,7 @@ import Mathlib.Algebra.GroupPower.Basic
 import Mathlib.Logic.Unique
 import Mathlib.Tactic.Nontriviality
 import Mathlib.Tactic.Lift
+import Mathlib.Tactic.Nontriviality
 
 #align_import algebra.group.units from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"
 
@@ -29,6 +30,9 @@ See also `Prime`, `Associated`, and `Irreducible` in `Mathlib.Algebra.Associated
 We provide `Mˣ` as notation for `Units M`,
 resembling the notation $R^{\times}$ for the units of a ring, which is common in mathematics.
 
+## TODO
+
+The results here should be used to golf the basic `Group` lemmas.
 -/
 
 
@@ -848,7 +852,8 @@ protected theorem mul_left_injective (h : IsUnit b) : Injective (· * b) :=
 
 end Monoid
 
-variable [DivisionMonoid M] {a : M}
+section DivisionMonoid
+variable [DivisionMonoid α] {a b c : α}
 
 @[to_additive (attr := simp)]
 protected theorem inv_mul_cancel : IsUnit a → a⁻¹ * a = 1 := by
@@ -864,8 +869,261 @@ protected theorem mul_inv_cancel : IsUnit a → a * a⁻¹ = 1 := by
 #align is_unit.mul_inv_cancel IsUnit.mul_inv_cancel
 #align is_add_unit.add_neg_cancel IsAddUnit.add_neg_cancel
 
+/-- The element of the group of units, corresponding to an element of a monoid which is a unit. As
+opposed to `IsUnit.unit`, the inverse is computable and comes from the inversion on `α`. This is
+useful to transfer properties of inversion in `Units α` to `α`. See also `toUnits`. -/
+@[to_additive (attr := simps val )
+"The element of the additive group of additive units, corresponding to an element of
+an additive monoid which is an additive unit. As opposed to `IsAddUnit.addUnit`, the negation is
+computable and comes from the negation on `α`. This is useful to transfer properties of negation
+in `AddUnits α` to `α`. See also `toAddUnits`."]
+def unit' (h : IsUnit a) : αˣ := ⟨a, a⁻¹, h.mul_inv_cancel, h.inv_mul_cancel⟩
+#align is_unit.unit' IsUnit.unit'
+#align is_add_unit.add_unit' IsAddUnit.addUnit'
+#align is_unit.coe_unit' IsUnit.val_unit'
+#align is_add_unit.coe_add_unit' IsAddUnit.val_addUnit'
+
+-- Porting note: TODO: `simps val_inv` fails
+@[to_additive] lemma val_inv_unit' (h : IsUnit a) : ↑(h.unit'⁻¹) = a⁻¹ := rfl
+#align is_unit.coe_inv_unit' IsUnit.val_inv_unit'
+#align is_add_unit.coe_neg_add_unit' IsAddUnit.val_neg_addUnit'
+
+@[to_additive (attr := simp)]
+protected lemma mul_inv_cancel_left (h : IsUnit a) : ∀ b, a * (a⁻¹ * b) = b :=
+  h.unit'.mul_inv_cancel_left
+#align is_unit.mul_inv_cancel_left IsUnit.mul_inv_cancel_left
+#align is_add_unit.add_neg_cancel_left IsAddUnit.add_neg_cancel_left
+
+@[to_additive (attr := simp)]
+protected lemma inv_mul_cancel_left (h : IsUnit a) : ∀ b, a⁻¹ * (a * b) = b :=
+  h.unit'.inv_mul_cancel_left
+#align is_unit.inv_mul_cancel_left IsUnit.inv_mul_cancel_left
+#align is_add_unit.neg_add_cancel_left IsAddUnit.neg_add_cancel_left
+
+@[to_additive (attr := simp)]
+protected lemma mul_inv_cancel_right (h : IsUnit b) (a : α) : a * b * b⁻¹ = a :=
+  h.unit'.mul_inv_cancel_right _
+#align is_unit.mul_inv_cancel_right IsUnit.mul_inv_cancel_right
+#align is_add_unit.add_neg_cancel_right IsAddUnit.add_neg_cancel_right
+
+@[to_additive (attr := simp)]
+protected lemma inv_mul_cancel_right (h : IsUnit b) (a : α) : a * b⁻¹ * b = a :=
+  h.unit'.inv_mul_cancel_right _
+#align is_unit.inv_mul_cancel_right IsUnit.inv_mul_cancel_right
+#align is_add_unit.neg_add_cancel_right IsAddUnit.neg_add_cancel_right
+
+@[to_additive]
+protected lemma div_self (h : IsUnit a) : a / a = 1 := by rw [div_eq_mul_inv, h.mul_inv_cancel]
+#align is_unit.div_self IsUnit.div_self
+#align is_add_unit.sub_self IsAddUnit.sub_self
+
+@[to_additive]
+protected lemma eq_mul_inv_iff_mul_eq (h : IsUnit c) : a = b * c⁻¹ ↔ a * c = b :=
+  h.unit'.eq_mul_inv_iff_mul_eq
+#align is_unit.eq_mul_inv_iff_mul_eq IsUnit.eq_mul_inv_iff_mul_eq
+#align is_add_unit.eq_add_neg_iff_add_eq IsAddUnit.eq_add_neg_iff_add_eq
+
+@[to_additive]
+protected lemma eq_inv_mul_iff_mul_eq (h : IsUnit b) : a = b⁻¹ * c ↔ b * a = c :=
+  h.unit'.eq_inv_mul_iff_mul_eq
+#align is_unit.eq_inv_mul_iff_mul_eq IsUnit.eq_inv_mul_iff_mul_eq
+#align is_add_unit.eq_neg_add_iff_add_eq IsAddUnit.eq_neg_add_iff_add_eq
+
+@[to_additive]
+protected lemma inv_mul_eq_iff_eq_mul (h : IsUnit a) : a⁻¹ * b = c ↔ b = a * c :=
+  h.unit'.inv_mul_eq_iff_eq_mul
+#align is_unit.inv_mul_eq_iff_eq_mul IsUnit.inv_mul_eq_iff_eq_mul
+#align is_add_unit.neg_add_eq_iff_eq_add IsAddUnit.neg_add_eq_iff_eq_add
+
+@[to_additive]
+protected lemma mul_inv_eq_iff_eq_mul (h : IsUnit b) : a * b⁻¹ = c ↔ a = c * b :=
+  h.unit'.mul_inv_eq_iff_eq_mul
+#align is_unit.mul_inv_eq_iff_eq_mul IsUnit.mul_inv_eq_iff_eq_mul
+#align is_add_unit.add_neg_eq_iff_eq_add IsAddUnit.add_neg_eq_iff_eq_add
+
+@[to_additive]
+protected lemma mul_inv_eq_one (h : IsUnit b) : a * b⁻¹ = 1 ↔ a = b :=
+  @Units.mul_inv_eq_one _ _ h.unit' _
+#align is_unit.mul_inv_eq_one IsUnit.mul_inv_eq_one
+#align is_add_unit.add_neg_eq_zero IsAddUnit.add_neg_eq_zero
+
+@[to_additive]
+protected lemma inv_mul_eq_one (h : IsUnit a) : a⁻¹ * b = 1 ↔ a = b :=
+  @Units.inv_mul_eq_one _ _ h.unit' _
+#align is_unit.inv_mul_eq_one IsUnit.inv_mul_eq_one
+#align is_add_unit.neg_add_eq_zero IsAddUnit.neg_add_eq_zero
+
+@[to_additive]
+protected lemma mul_eq_one_iff_eq_inv (h : IsUnit b) : a * b = 1 ↔ a = b⁻¹ :=
+  @Units.mul_eq_one_iff_eq_inv _ _ h.unit' _
+#align is_unit.mul_eq_one_iff_eq_inv IsUnit.mul_eq_one_iff_eq_inv
+#align is_add_unit.add_eq_zero_iff_eq_neg IsAddUnit.add_eq_zero_iff_eq_neg
+
+@[to_additive]
+protected lemma mul_eq_one_iff_inv_eq (h : IsUnit a) : a * b = 1 ↔ a⁻¹ = b :=
+  @Units.mul_eq_one_iff_inv_eq _ _ h.unit' _
+#align is_unit.mul_eq_one_iff_inv_eq IsUnit.mul_eq_one_iff_inv_eq
+#align is_add_unit.add_eq_zero_iff_neg_eq IsAddUnit.add_eq_zero_iff_neg_eq
+
+@[to_additive (attr := simp)]
+protected lemma div_mul_cancel (h : IsUnit b) (a : α) : a / b * b = a := by
+  rw [div_eq_mul_inv, h.inv_mul_cancel_right]
+#align is_unit.div_mul_cancel IsUnit.div_mul_cancel
+#align is_add_unit.sub_add_cancel IsAddUnit.sub_add_cancel
+
+@[to_additive (attr := simp)]
+protected lemma mul_div_cancel (h : IsUnit b) (a : α) : a * b / b = a := by
+  rw [div_eq_mul_inv, h.mul_inv_cancel_right]
+#align is_unit.mul_div_cancel IsUnit.mul_div_cancel
+#align is_add_unit.add_sub_cancel IsAddUnit.add_sub_cancel
+
+@[to_additive]
+protected lemma mul_one_div_cancel (h : IsUnit a) : a * (1 / a) = 1 := by simp [h]
+#align is_unit.mul_one_div_cancel IsUnit.mul_one_div_cancel
+#align is_add_unit.add_zero_sub_cancel IsAddUnit.add_zero_sub_cancel
+
+@[to_additive]
+protected lemma one_div_mul_cancel (h : IsUnit a) : 1 / a * a = 1 := by simp [h]
+#align is_unit.one_div_mul_cancel IsUnit.one_div_mul_cancel
+#align is_add_unit.zero_sub_add_cancel IsAddUnit.zero_sub_add_cancel
+
+@[to_additive]
+lemma inv (h : IsUnit a) : IsUnit a⁻¹ := by
+  obtain ⟨u, hu⟩ := h
+  rw [← hu, ← Units.val_inv_eq_inv_val]
+  exact Units.isUnit _
+#align is_unit.inv IsUnit.inv
+#align is_add_unit.neg IsAddUnit.neg
+
+@[to_additive] lemma div (ha : IsUnit a) (hb : IsUnit b) : IsUnit (a / b) := by
+  rw [div_eq_mul_inv]; exact ha.mul hb.inv
+#align is_unit.div IsUnit.div
+#align is_add_unit.sub IsAddUnit.sub
+
+@[to_additive]
+protected lemma div_left_inj (h : IsUnit c) : a / c = b / c ↔ a = b := by
+  simp only [div_eq_mul_inv]
+  exact Units.mul_left_inj h.inv.unit'
+#align is_unit.div_left_inj IsUnit.div_left_inj
+#align is_add_unit.sub_left_inj IsAddUnit.sub_left_inj
+
+@[to_additive]
+protected lemma div_eq_iff (h : IsUnit b) : a / b = c ↔ a = c * b := by
+  rw [div_eq_mul_inv, h.mul_inv_eq_iff_eq_mul]
+#align is_unit.div_eq_iff IsUnit.div_eq_iff
+#align is_add_unit.sub_eq_iff IsAddUnit.sub_eq_iff
+
+@[to_additive]
+protected lemma eq_div_iff (h : IsUnit c) : a = b / c ↔ a * c = b := by
+  rw [div_eq_mul_inv, h.eq_mul_inv_iff_mul_eq]
+#align is_unit.eq_div_iff IsUnit.eq_div_iff
+#align is_add_unit.eq_sub_iff IsAddUnit.eq_sub_iff
+
+@[to_additive]
+protected lemma div_eq_of_eq_mul (h : IsUnit b) : a = c * b → a / b = c :=
+  h.div_eq_iff.2
+#align is_unit.div_eq_of_eq_mul IsUnit.div_eq_of_eq_mul
+#align is_add_unit.sub_eq_of_eq_add IsAddUnit.sub_eq_of_eq_add
+
+@[to_additive]
+protected lemma eq_div_of_mul_eq (h : IsUnit c) : a * c = b → a = b / c :=
+  h.eq_div_iff.2
+#align is_unit.eq_div_of_mul_eq IsUnit.eq_div_of_mul_eq
+#align is_add_unit.eq_sub_of_add_eq IsAddUnit.eq_sub_of_add_eq
+
+@[to_additive]
+protected lemma div_eq_one_iff_eq (h : IsUnit b) : a / b = 1 ↔ a = b :=
+  ⟨eq_of_div_eq_one, fun hab => hab.symm ▸ h.div_self⟩
+#align is_unit.div_eq_one_iff_eq IsUnit.div_eq_one_iff_eq
+#align is_add_unit.sub_eq_zero_iff_eq IsAddUnit.sub_eq_zero_iff_eq
+
+/-- The `Group` version of this lemma is `div_mul_cancel'''` -/
+@[to_additive "The `AddGroup` version of this lemma is `sub_add_cancel''`"]
+protected lemma div_mul_left (h : IsUnit b) : b / (a * b) = 1 / a := by
+  rw [div_eq_mul_inv, mul_inv_rev, h.mul_inv_cancel_left, one_div]
+#align is_unit.div_mul_left IsUnit.div_mul_left
+#align is_add_unit.sub_add_left IsAddUnit.sub_add_left
+
+@[to_additive]
+protected lemma mul_div_mul_right (h : IsUnit c) (a b : α) : a * c / (b * c) = a / b := by
+  simp only [div_eq_mul_inv, mul_inv_rev, mul_assoc, h.mul_inv_cancel_left]
+#align is_unit.mul_div_mul_right IsUnit.mul_div_mul_right
+#align is_add_unit.add_sub_add_right IsAddUnit.add_sub_add_right
+
+@[to_additive]
+protected lemma mul_mul_div (a : α) (h : IsUnit b) : a * b * (1 / b) = a := by simp [h]
+#align is_unit.mul_mul_div IsUnit.mul_mul_div
+#align is_add_unit.add_add_sub IsAddUnit.add_add_sub
+
+end DivisionMonoid
+
+section DivisionCommMonoid
+variable [DivisionCommMonoid α] {a b c d : α}
+
+@[to_additive]
+protected lemma div_mul_right (h : IsUnit a) (b : α) : a / (a * b) = 1 / b := by
+  rw [mul_comm, h.div_mul_left]
+#align is_unit.div_mul_right IsUnit.div_mul_right
+#align is_add_unit.sub_add_right IsAddUnit.sub_add_right
+
+@[to_additive]
+protected lemma mul_div_cancel_left (h : IsUnit a) (b : α) : a * b / a = b := by
+  rw [mul_comm, h.mul_div_cancel]
+#align is_unit.mul_div_cancel_left IsUnit.mul_div_cancel_left
+#align is_add_unit.add_sub_cancel_left IsAddUnit.add_sub_cancel_left
+
+@[to_additive]
+protected lemma mul_div_cancel' (h : IsUnit a) (b : α) : a * (b / a) = b := by
+  rw [mul_comm, h.div_mul_cancel]
+#align is_unit.mul_div_cancel' IsUnit.mul_div_cancel'
+#align is_add_unit.add_sub_cancel' IsAddUnit.add_sub_cancel'
+
+@[to_additive]
+protected lemma mul_div_mul_left (h : IsUnit c) (a b : α) : c * a / (c * b) = a / b := by
+  rw [mul_comm c, mul_comm c, h.mul_div_mul_right]
+#align is_unit.mul_div_mul_left IsUnit.mul_div_mul_left
+#align is_add_unit.add_sub_add_left IsAddUnit.add_sub_add_left
+
+@[to_additive]
+protected lemma mul_eq_mul_of_div_eq_div (hb : IsUnit b) (hd : IsUnit d)
+    (a c : α) (h : a / b = c / d) : a * d = c * b := by
+  rw [← mul_one a, ← hb.div_self, ← mul_comm_div, h, div_mul_eq_mul_div, hd.div_mul_cancel]
+#align is_unit.mul_eq_mul_of_div_eq_div IsUnit.mul_eq_mul_of_div_eq_div
+#align is_add_unit.add_eq_add_of_sub_eq_sub IsAddUnit.add_eq_add_of_sub_eq_sub
+
+@[to_additive]
+protected lemma div_eq_div_iff (hb : IsUnit b) (hd : IsUnit d) :
+    a / b = c / d ↔ a * d = c * b := by
+  rw [← (hb.mul hd).mul_left_inj, ← mul_assoc, hb.div_mul_cancel, ← mul_assoc, mul_right_comm,
+    hd.div_mul_cancel]
+#align is_unit.div_eq_div_iff IsUnit.div_eq_div_iff
+#align is_add_unit.sub_eq_sub_iff IsAddUnit.sub_eq_sub_iff
+
+@[to_additive]
+protected lemma div_div_cancel (h : IsUnit a) : a / (a / b) = b := by
+  rw [div_div_eq_mul_div, h.mul_div_cancel_left]
+#align is_unit.div_div_cancel IsUnit.div_div_cancel
+#align is_add_unit.sub_sub_cancel IsAddUnit.sub_sub_cancel
+
+@[to_additive]
+protected lemma div_div_cancel_left (h : IsUnit a) : a / b / a = b⁻¹ := by
+  rw [div_eq_mul_inv, div_eq_mul_inv, mul_right_comm, h.mul_inv_cancel, one_mul]
+#align is_unit.div_div_cancel_left IsUnit.div_div_cancel_left
+#align is_add_unit.sub_sub_cancel_left IsAddUnit.sub_sub_cancel_left
+
+end DivisionCommMonoid
 end IsUnit
 
+@[field_simps]
+lemma divp_eq_div [DivisionMonoid α] (a : α) (u : αˣ) : a /ₚ u = a / u :=
+  by rw [div_eq_mul_inv, divp, u.val_inv_eq_inv_val]
+#align divp_eq_div divp_eq_div
+
+@[to_additive]
+lemma Group.isUnit [Group α] (a : α) : IsUnit a := ⟨⟨a, a⁻¹, mul_inv_self _, inv_mul_self _⟩, rfl⟩
+#align group.is_unit Group.isUnit
+#align add_group.is_add_unit AddGroup.isAddUnit
+
 -- namespace
 end IsUnit

Chore: Move Units lemmas earlier (#9461)

Part of #9411

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>

7522333a

Diff

@@ -4,6 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau, Mario Carneiro, Johannes Hölzl, Chris Hughes, Jens Wagemaker, Jon Eugster
 -/
 import Mathlib.Algebra.Group.Basic
+import Mathlib.Algebra.GroupPower.Basic
 import Mathlib.Logic.Unique
 import Mathlib.Tactic.Nontriviality
 import Mathlib.Tactic.Lift
@@ -97,7 +98,7 @@ theorem unique_one {α : Type*} [Unique α] [One α] : default = (1 : α) :=
 end HasElem
 
 namespace Units
-
+section Monoid
 variable [Monoid α]
 
 -- Porting note: unclear whether this should be a `CoeHead` or `CoeTail`
@@ -185,7 +186,7 @@ theorem copy_eq (u : αˣ) (val hv inv hi) : u.copy val hv inv hi = u :=
 
 /-- Units of a monoid form have a multiplication and multiplicative identity. -/
 @[to_additive "Additive units of an additive monoid have an addition and an additive identity."]
-instance : MulOneClass αˣ where
+instance instMulOneClass : MulOneClass αˣ where
   mul u₁ u₂ :=
     ⟨u₁.val * u₂.val, u₂.inv * u₁.inv,
       by rw [mul_assoc, ← mul_assoc u₂.val, val_inv, one_mul, val_inv],
@@ -194,23 +195,6 @@ instance : MulOneClass αˣ where
   one_mul u := ext <| one_mul (u : α)
   mul_one u := ext <| mul_one (u : α)
 
-/-- Units of a monoid form a group. -/
-@[to_additive "Additive units of an additive monoid form an additive group."]
-instance : Group αˣ :=
-  { (inferInstance : MulOneClass αˣ) with
-    mul_assoc := fun _ _ _ => ext <| mul_assoc _ _ _,
-    inv := Inv.inv, mul_left_inv := fun u => ext u.inv_val }
-
-/-- Units of a commutative monoid form a commutative group. -/
-@[to_additive "Additive units of an additive commutative monoid form
-an additive commutative group."]
-instance instCommGroupUnits {α} [CommMonoid α] : CommGroup αˣ :=
-  -- note: the original ported file had `{ (inferInstance : Group αˣ) with ... }`
-  -- and this was removed because it was causing slowdowns: see lean4#2387
-  { mul_comm := fun _ _ => ext <| mul_comm _ _ }
-#align units.comm_group Units.instCommGroupUnits
-#align add_units.add_comm_group AddUnits.instAddCommGroupAddUnits
-
 /-- Units of a monoid are inhabited because `1` is a unit. -/
 @[to_additive "Additive units of an additive monoid are inhabited because `0` is an additive unit."]
 instance : Inhabited αˣ :=
@@ -270,6 +254,11 @@ theorem mul_inv : (a * ↑a⁻¹ : α) = 1 :=
 #align units.mul_inv Units.mul_inv
 #align add_units.add_neg AddUnits.add_neg
 
+@[to_additive] lemma commute_coe_inv : Commute (a : α) ↑a⁻¹ := by
+  rw [Commute, SemiconjBy, inv_mul, mul_inv]
+
+@[to_additive] lemma commute_inv_coe : Commute ↑a⁻¹ (a : α) := a.commute_coe_inv.symm
+
 @[to_additive]
 theorem inv_mul_of_eq {a : α} (h : ↑u = a) : ↑u⁻¹ * a = 1 := by rw [← h, u.inv_mul]
 #align units.inv_mul_of_eq Units.inv_mul_of_eq
@@ -374,6 +363,49 @@ protected theorem eq_inv_of_mul_eq_one_right {a : α} (h : a * u = 1) : a = ↑u
 #align units.eq_inv_of_mul_eq_one_right Units.eq_inv_of_mul_eq_one_right
 #align add_units.eq_neg_of_add_eq_zero_right AddUnits.eq_neg_of_add_eq_zero_right
 
+@[to_additive]
+instance instMonoid : Monoid αˣ :=
+  { (inferInstance : MulOneClass αˣ) with
+    mul_assoc := fun _ _ _ => ext <| mul_assoc _ _ _,
+    npow := fun n a ↦
+      { val := a ^ n
+        inv := a⁻¹ ^ n
+        val_inv := by rw [← a.commute_coe_inv.mul_pow]; simp
+        inv_val := by rw [← a.commute_inv_coe.mul_pow]; simp }
+    npow_zero := fun a ↦ by ext; simp
+    npow_succ := fun n a ↦ by ext; simp [pow_succ] }
+
+/-- Units of a monoid form a group. -/
+@[to_additive "Additive units of an additive monoid form an additive group."]
+instance instGroup : Group αˣ :=
+  { (inferInstance : Monoid αˣ) with
+    inv := Inv.inv
+    mul_left_inv := fun u => ext u.inv_val
+    div := fun a b ↦
+      { val := a * b⁻¹
+        inv := b * a⁻¹
+        val_inv := by rw [mul_assoc, inv_mul_cancel_left, mul_inv]
+        inv_val := by rw [mul_assoc, inv_mul_cancel_left, mul_inv] }
+    zpow := fun n a ↦ match n, a with
+      | Int.ofNat n, a => a ^ n
+      | Int.negSucc n, a => (a ^ n.succ)⁻¹
+    zpow_zero' := fun a ↦ by simp
+    zpow_succ' := fun n a ↦ by simp [pow_succ]
+    zpow_neg' := fun n a ↦ by simp }
+
+/-- Units of a commutative monoid form a commutative group. -/
+@[to_additive "Additive units of an additive commutative monoid form
+an additive commutative group."]
+instance instCommGroupUnits {α} [CommMonoid α] : CommGroup αˣ where
+  mul_comm := fun _ _ => ext <| mul_comm _ _
+#align units.comm_group Units.instCommGroupUnits
+#align add_units.add_comm_group AddUnits.instAddCommGroupAddUnits
+
+@[to_additive (attr := simp, norm_cast)]
+lemma val_pow_eq_pow_val (n : ℕ) : ↑(a ^ n) = (a ^ n : α) := rfl
+#align units.coe_pow Units.val_pow_eq_pow_val
+#align add_units.coe_nsmul AddUnits.val_nsmul_eq_nsmul_val
+
 @[to_additive (attr := simp)]
 theorem mul_inv_eq_one {a : α} : a * ↑u⁻¹ = 1 ↔ a = u :=
   ⟨inv_inv u ▸ Units.eq_inv_of_mul_eq_one_right, fun h => mul_inv_of_eq h.symm⟩
@@ -402,11 +434,21 @@ theorem inv_unique {u₁ u₂ : αˣ} (h : (↑u₁ : α) = ↑u₂) : (↑u₁
 #align units.inv_unique Units.inv_unique
 #align add_units.neg_unique AddUnits.neg_unique
 
-@[to_additive (attr := simp)]
-theorem val_inv_eq_inv_val {M : Type*} [DivisionMonoid M] (u : Units M) : ↑u⁻¹ = (u⁻¹ : M) :=
+end Monoid
+
+section DivisionMonoid
+variable [DivisionMonoid α]
+
+@[to_additive (attr := simp, norm_cast)] lemma val_inv_eq_inv_val (u : αˣ) : ↑u⁻¹ = (u⁻¹ : α) :=
   Eq.symm <| inv_eq_of_mul_eq_one_right u.mul_inv
 #align units.coe_inv Units.val_inv_eq_inv_val
 
+@[to_additive (attr := simp, norm_cast)]
+lemma val_div_eq_div_val : ∀ u₁ u₂ : αˣ, ↑(u₁ / u₂) = (u₁ / u₂ : α) := by simp [div_eq_mul_inv]
+#align units.coe_div Units.val_div_eq_div_val
+#align add_units.coe_sub AddUnits.val_neg_eq_neg_val
+
+end DivisionMonoid
 end Units
 
 /-- For `a, b` in a `CommMonoid` such that `a * b = 1`, makes a unit out of `a`. -/
@@ -629,20 +671,35 @@ theorem isUnit_of_mul_eq_one [CommMonoid M] (a b : M) (h : a * b = 1) : IsUnit a
 #align is_unit_of_mul_eq_one isUnit_of_mul_eq_one
 #align is_add_unit_of_add_eq_zero isAddUnit_of_add_eq_zero
 
+section Monoid
+variable [Monoid M] {a b : M}
+
 @[to_additive IsAddUnit.exists_neg]
-theorem IsUnit.exists_right_inv [Monoid M] {a : M} (h : IsUnit a) : ∃ b, a * b = 1 := by
+lemma IsUnit.exists_right_inv (h : IsUnit a) : ∃ b, a * b = 1 := by
   rcases h with ⟨⟨a, b, hab, _⟩, rfl⟩
   exact ⟨b, hab⟩
 #align is_unit.exists_right_inv IsUnit.exists_right_inv
 #align is_add_unit.exists_neg IsAddUnit.exists_neg
 
 @[to_additive IsAddUnit.exists_neg']
-theorem IsUnit.exists_left_inv [Monoid M] {a : M} (h : IsUnit a) : ∃ b, b * a = 1 := by
+lemma IsUnit.exists_left_inv [Monoid M] {a : M} (h : IsUnit a) : ∃ b, b * a = 1 := by
   rcases h with ⟨⟨a, b, _, hba⟩, rfl⟩
   exact ⟨b, hba⟩
 #align is_unit.exists_left_inv IsUnit.exists_left_inv
 #align is_add_unit.exists_neg' IsAddUnit.exists_neg'
 
+@[to_additive] lemma IsUnit.mul : IsUnit a → IsUnit b → IsUnit (a * b) := by
+  rintro ⟨x, rfl⟩ ⟨y, rfl⟩; exact ⟨x * y, rfl⟩
+#align is_unit.mul IsUnit.mul
+#align is_add_unit.add IsAddUnit.add
+
+@[to_additive] lemma IsUnit.pow (n : ℕ) : IsUnit a → IsUnit (a ^ n) := by
+  rintro ⟨u, rfl⟩; exact ⟨u ^ n, rfl⟩
+#align is_unit.pow IsUnit.pow
+#align is_add_unit.nsmul IsAddUnit.nsmul
+
+end Monoid
+
 @[to_additive]
 theorem isUnit_iff_exists_inv [CommMonoid M] {a : M} : IsUnit a ↔ ∃ b, a * b = 1 :=
   ⟨fun h => h.exists_right_inv, fun ⟨b, hab⟩ => isUnit_of_mul_eq_one _ b hab⟩
@@ -655,13 +712,6 @@ theorem isUnit_iff_exists_inv' [CommMonoid M] {a : M} : IsUnit a ↔ ∃ b, b *
 #align is_unit_iff_exists_inv' isUnit_iff_exists_inv'
 #align is_add_unit_iff_exists_neg' isAddUnit_iff_exists_neg'
 
-@[to_additive]
-theorem IsUnit.mul [Monoid M] {x y : M} : IsUnit x → IsUnit y → IsUnit (x * y) := by
-  rintro ⟨x, rfl⟩ ⟨y, rfl⟩
-  exact ⟨x * y, Units.val_mul _ _⟩
-#align is_unit.mul IsUnit.mul
-#align is_add_unit.add IsAddUnit.add
-
 /-- Multiplication by a `u : Mˣ` on the right doesn't affect `IsUnit`. -/
 @[to_additive (attr := simp)
 "Addition of a `u : AddUnits M` on the right doesn't affect `IsAddUnit`."]

chore: Replace (· op ·) a by (a op ·) (#8843)

I used the regex $\(· (.) ·$ (.)\), replacing with ($2 $1 ·).

d14658b4

Diff

@@ -785,7 +785,7 @@ protected theorem mul_right_cancel (h : IsUnit b) : a * b = c * b → a = c :=
 #align is_add_unit.add_right_cancel IsAddUnit.add_right_cancel
 
 @[to_additive]
-protected theorem mul_right_injective (h : IsUnit a) : Injective ((· * ·) a) :=
+protected theorem mul_right_injective (h : IsUnit a) : Injective (a * ·) :=
   fun _ _ => h.mul_left_cancel
 #align is_unit.mul_right_injective IsUnit.mul_right_injective
 #align is_add_unit.add_right_injective IsAddUnit.add_right_injective

chore: space after ← (#8178)

Co-authored-by: Moritz Firsching <firsching@google.com>

5fb9beab

Diff

@@ -749,7 +749,7 @@ theorem val_inv_mul (h : IsUnit a) : ↑h.unit⁻¹ * a = 1 :=
 
 @[to_additive (attr := simp)]
 theorem mul_val_inv (h : IsUnit a) : a * ↑h.unit⁻¹ = 1 := by
-  rw [←h.unit.mul_inv]; congr
+  rw [← h.unit.mul_inv]; congr
 #align is_unit.mul_coe_inv IsUnit.mul_val_inv
 #align is_add_unit.add_coe_neg IsAddUnit.add_val_neg

perf: remove overspecified fields (#6965)

This removes redundant field values of the form add := add for smaller terms and less unfolding during unification.

A list of all files containing a structure instance of the form { a1, ... with x1 := val, ... } where some xi is a field of some aj was generated by modifying the structure instance elaboration algorithm to print such overlaps to stdout in a custom toolchain.

Using that toolchain, I went through each file on the list and attempted to remove algebraic fields that overlapped and were redundant, eg add := add and not toFun (though some other ones did creep in). If things broke (which was the case in a couple of cases), I did not push further and reverted.

It is possible that pushing harder and trying to remove all redundant overlaps will yield further improvements.

12150475

Diff

@@ -198,7 +198,6 @@ instance : MulOneClass αˣ where
 @[to_additive "Additive units of an additive monoid form an additive group."]
 instance : Group αˣ :=
   { (inferInstance : MulOneClass αˣ) with
-    one := 1,
     mul_assoc := fun _ _ _ => ext <| mul_assoc _ _ _,
     inv := Inv.inv, mul_left_inv := fun u => ext u.inv_val }

chore: delay import of Tactic.Common (#7000)

I know that this is contrary to what we've done previously, but:

I'm trying to upstream a great many tactics from Mathlib to Std (essentially, everything that non-mathematicians want too).
This makes it much easier for me to see what is going on, and understand the import requirements (particularly for the "big" tactics norm_num / ring / linarith)
It's actually not as bad as it looks here, because as these tactics move up to Std they will start disappearing again from explicit imports, but Mathlib can happily import all of Std.

(Oh

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

4f3418a7

Diff

@@ -6,6 +6,7 @@ Authors: Kenny Lau, Mario Carneiro, Johannes Hölzl, Chris Hughes, Jens Wagemake
 import Mathlib.Algebra.Group.Basic
 import Mathlib.Logic.Unique
 import Mathlib.Tactic.Nontriviality
+import Mathlib.Tactic.Lift
 
 #align_import algebra.group.units from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"

feat: split Logic.Nontrivial (#6959)

This continues reducing the import requirements for the basic algebraic hierarchy.

In combination with #6954 #6955 #6956 #6957, this reduces the imports for Mathlib.Algebra.Field.Defs from

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

560425d2

Diff

@@ -4,7 +4,6 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau, Mario Carneiro, Johannes Hölzl, Chris Hughes, Jens Wagemaker, Jon Eugster
 -/
 import Mathlib.Algebra.Group.Basic
-import Mathlib.Logic.Nontrivial
 import Mathlib.Logic.Unique
 import Mathlib.Tactic.Nontriviality

fix: simps config for Units (#6514)

552f9b55

Diff

@@ -112,13 +112,21 @@ instance instInv : Inv αˣ :=
   ⟨fun u => ⟨u.2, u.1, u.4, u.3⟩⟩
 attribute [instance] AddUnits.instNeg
 
-/- porting note: the result of these definitions is syntactically equal to `Units.val` and
-`Units.inv` because of the way coercions work in Lean 4, so there is no need for these custom
-`simp` projections. -/
+/- porting note: the result of these definitions is syntactically equal to `Units.val` because of
+the way coercions work in Lean 4, so there is no need for these custom `simp` projections. -/
 #noalign units.simps.coe
 #noalign add_units.simps.coe
-#noalign units.simps.coe_inv
-#noalign add_units.simps.coe_neg
+
+/-- See Note [custom simps projection] -/
+@[to_additive "See Note [custom simps projection]"]
+def Simps.val_inv (u : αˣ) : α := ↑(u⁻¹)
+#align units.simps.coe_inv Units.Simps.val_inv
+#align add_units.simps.coe_neg AddUnits.Simps.val_neg
+
+initialize_simps_projections Units (as_prefix val, val_inv → null, inv → val_inv, as_prefix val_inv)
+
+initialize_simps_projections AddUnits
+  (as_prefix val, val_neg → null, neg → val_neg, as_prefix val_neg)
 
 -- Porting note: removed `simp` tag because of the tautology
 @[to_additive]
@@ -164,6 +172,10 @@ def copy (u : αˣ) (val : α) (hv : val = u) (inv : α) (hi : inv = ↑u⁻¹)
   { val, inv, inv_val := hv.symm ▸ hi.symm ▸ u.inv_val, val_inv := hv.symm ▸ hi.symm ▸ u.val_inv }
 #align units.copy Units.copy
 #align add_units.copy AddUnits.copy
+#align units.coe_copy Units.val_copy
+#align add_units.coe_copy AddUnits.val_copy
+#align units.coe_inv_copy Units.val_inv_copy
+#align add_units.coe_neg_copy AddUnits.val_neg_copy
 
 @[to_additive]
 theorem copy_eq (u : αˣ) (val hv inv hi) : u.copy val hv inv hi = u :=
@@ -241,12 +253,9 @@ theorem inv_mk (x y : α) (h₁ h₂) : (mk x y h₁ h₂)⁻¹ = mk y x h₂ h
 #noalign units.val_eq_coe
 #noalign add_units.val_eq_coe
 
-@[to_additive]
+@[to_additive (attr := simp)]
 theorem inv_eq_val_inv : a.inv = ((a⁻¹ : αˣ) : α) :=
   rfl
--- Porting note: the lower priority is needed to appease the `simpNF` linter
--- Note that `to_additive` doesn't copy `simp` priorities, so we use this as a workaround
-attribute [simp 900] Units.inv_eq_val_inv AddUnits.neg_eq_val_neg
 #align units.inv_eq_coe_inv Units.inv_eq_val_inv
 #align add_units.neg_eq_coe_neg AddUnits.neg_eq_val_neg

chore: banish Type _ and Sort _ (#6499)

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

32de3f67

Diff

@@ -89,7 +89,7 @@ attribute [coe] AddUnits.val
 section HasElem
 
 @[to_additive]
-theorem unique_one {α : Type _} [Unique α] [One α] : default = (1 : α) :=
+theorem unique_one {α : Type*} [Unique α] [One α] : default = (1 : α) :=
   Unique.default_eq 1
 #align unique_has_one unique_one
 #align unique_has_zero unique_zero
@@ -395,7 +395,7 @@ theorem inv_unique {u₁ u₂ : αˣ} (h : (↑u₁ : α) = ↑u₂) : (↑u₁
 #align add_units.neg_unique AddUnits.neg_unique
 
 @[to_additive (attr := simp)]
-theorem val_inv_eq_inv_val {M : Type _} [DivisionMonoid M] (u : Units M) : ↑u⁻¹ = (u⁻¹ : M) :=
+theorem val_inv_eq_inv_val {M : Type*} [DivisionMonoid M] (u : Units M) : ↑u⁻¹ = (u⁻¹ : M) :=
   Eq.symm <| inv_eq_of_mul_eq_one_right u.mul_inv
 #align units.coe_inv Units.val_inv_eq_inv_val
 
@@ -572,7 +572,7 @@ end CommMonoid
 
 section IsUnit
 
-variable {M : Type _} {N : Type _}
+variable {M : Type*} {N : Type*}
 
 /-- 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 : Mˣ`, where
@@ -669,7 +669,7 @@ theorem Units.isUnit_mul_units [Monoid M] (a : M) (u : Mˣ) : IsUnit (a * u) ↔
 /-- Multiplication by a `u : Mˣ` on the left doesn't affect `IsUnit`. -/
 @[to_additive (attr := simp)
 "Addition of a `u : AddUnits M` on the left doesn't affect `IsAddUnit`."]
-theorem Units.isUnit_units_mul {M : Type _} [Monoid M] (u : Mˣ) (a : M) :
+theorem Units.isUnit_units_mul {M : Type*} [Monoid M] (u : Mˣ) (a : M) :
     IsUnit (↑u * a) ↔ IsUnit a :=
   Iff.intro
     (fun ⟨v, hv⟩ => by
@@ -814,7 +814,7 @@ end IsUnit
 -- section
 section NoncomputableDefs
 
-variable {M : Type _}
+variable {M : Type*}
 
 /-- Constructs a `Group` structure on a `Monoid` consisting only of units. -/
 noncomputable def groupOfIsUnit [hM : Monoid M] (h : ∀ a : M, IsUnit a) : Group M :=

chore: ensure all instances referred to directly have explicit names (#6423)

Per https://github.com/leanprover/lean4/issues/2343, we are going to need to change the automatic generation of instance names, as they become too long.

This PR ensures that everywhere in Mathlib that refers to an instance by name, that name is given explicitly, rather than being automatically generated.

There are four exceptions, which are now commented, with links to https://github.com/leanprover/lean4/issues/2343.

This was implemented by running Mathlib against a modified Lean that appended _ᾰ to all automatically generated names, and fixing everything.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

65a35f78

Diff

@@ -105,7 +105,6 @@ variable [Monoid α]
 @[to_additive "An additive unit can be interpreted as a term in the base `AddMonoid`."]
 instance : CoeHead αˣ α :=
   ⟨val⟩
-attribute [instance] AddUnits.instCoeHeadAddUnits
 
 /-- The inverse of a unit in a `Monoid`. -/
 @[to_additive "The additive inverse of an additive unit in an `AddMonoid`."]
@@ -152,7 +151,6 @@ theorem ext_iff {a b : αˣ} : a = b ↔ (a : α) = b :=
 @[to_additive "Additive units have decidable equality
 if the base `AddMonoid` has deciable equality."]
 instance [DecidableEq α] : DecidableEq αˣ := fun _ _ => decidable_of_iff' _ ext_iff
-attribute [instance] AddUnits.instDecidableEqAddUnits
 
 @[to_additive (attr := simp)]
 theorem mk_val (u : αˣ) (y h₁ h₂) : mk (u : α) y h₁ h₂ = u :=
@@ -183,7 +181,6 @@ instance : MulOneClass αˣ where
   one := ⟨1, 1, one_mul 1, one_mul 1⟩
   one_mul u := ext <| one_mul (u : α)
   mul_one u := ext <| mul_one (u : α)
-attribute [instance] AddUnits.instAddZeroClassAddUnits
 
 /-- Units of a monoid form a group. -/
 @[to_additive "Additive units of an additive monoid form an additive group."]
@@ -192,31 +189,28 @@ instance : Group αˣ :=
     one := 1,
     mul_assoc := fun _ _ _ => ext <| mul_assoc _ _ _,
     inv := Inv.inv, mul_left_inv := fun u => ext u.inv_val }
-attribute [instance] AddUnits.instAddGroupAddUnits
 
 /-- Units of a commutative monoid form a commutative group. -/
 @[to_additive "Additive units of an additive commutative monoid form
 an additive commutative group."]
-instance {α} [CommMonoid α] : CommGroup αˣ :=
+instance instCommGroupUnits {α} [CommMonoid α] : CommGroup αˣ :=
   -- note: the original ported file had `{ (inferInstance : Group αˣ) with ... }`
   -- and this was removed because it was causing slowdowns: see lean4#2387
   { mul_comm := fun _ _ => ext <| mul_comm _ _ }
-attribute [instance] AddUnits.instAddCommGroupAddUnitsToAddMonoid
-#align units.comm_group Units.instCommGroupUnitsToMonoid
-#align add_units.add_comm_group AddUnits.instAddCommGroupAddUnitsToAddMonoid
+#align units.comm_group Units.instCommGroupUnits
+#align add_units.add_comm_group AddUnits.instAddCommGroupAddUnits
 
 /-- Units of a monoid are inhabited because `1` is a unit. -/
 @[to_additive "Additive units of an additive monoid are inhabited because `0` is an additive unit."]
 instance : Inhabited αˣ :=
   ⟨1⟩
-attribute [instance] AddUnits.instInhabitedAddUnits
+
 
 /-- Units of a monoid have a representation of the base value in the `Monoid`. -/
 @[to_additive "Additive units of an additive monoid have a representation of the base value in
 the `AddMonoid`."]
 instance [Repr α] : Repr αˣ :=
   ⟨reprPrec ∘ val⟩
-attribute [instance] AddUnits.instReprAddUnits
 
 variable (a b c : αˣ) {u : αˣ}
 
@@ -755,7 +749,6 @@ theorem mul_val_inv (h : IsUnit a) : a * ↑h.unit⁻¹ = 1 := by
 @[to_additive "`IsAddUnit x` is decidable if we can decide if `x` comes from `AddUnits M`."]
 instance (x : M) [h : Decidable (∃ u : Mˣ, ↑u = x)] : Decidable (IsUnit x) :=
   h
-attribute [instance] IsAddUnit.instDecidableIsAddUnit
 
 @[to_additive]
 theorem mul_left_inj (h : IsUnit a) : b * a = c * a ↔ b = c :=

chore: Doc-string fixes (#6399)

Just some casing issues in some doc-strings in

Algebra.Group.Commute
Algebra.Group.Units

ffeae88c

Diff

@@ -148,7 +148,7 @@ theorem ext_iff {a b : αˣ} : a = b ↔ (a : α) = b :=
 #align units.ext_iff Units.ext_iff
 #align add_units.ext_iff AddUnits.ext_iff
 
-/-- Units have decidable equality if the base `Monoid` has deciable equality. -/
+/-- Units have decidable equality if the base `Monoid` has decidable equality. -/
 @[to_additive "Additive units have decidable equality
 if the base `AddMonoid` has deciable equality."]
 instance [DecidableEq α] : DecidableEq αˣ := fun _ _ => decidable_of_iff' _ ext_iff
@@ -409,7 +409,7 @@ end Units
 
 /-- For `a, b` in a `CommMonoid` such that `a * b = 1`, makes a unit out of `a`. -/
 @[to_additive
-  "For `a, b` in an `AddCommMonoid` such that `a + b = 0`, makes an add_unit out of `a`."]
+  "For `a, b` in an `AddCommMonoid` such that `a + b = 0`, makes an addUnit out of `a`."]
 def Units.mkOfMulEqOne [CommMonoid α] (a b : α) (hab : a * b = 1) : αˣ :=
   ⟨a, b, hab, (mul_comm b a).trans hab⟩
 #align units.mk_of_mul_eq_one Units.mkOfMulEqOne

chore: Units -- to_additive no longer complains (#6400)

Remove a porting note, since the reported to_additive issue seems resolved.

Algebra.Group.Units

48ee5fd6

Diff

@@ -647,11 +647,9 @@ theorem isUnit_iff_exists_inv [CommMonoid M] {a : M} : IsUnit a ↔ ∃ b, a * b
 #align is_unit_iff_exists_inv isUnit_iff_exists_inv
 #align is_add_unit_iff_exists_neg isAddUnit_iff_exists_neg
 
--- Porting note: `to_additive` complains if using `simp [isUnit_iff_exists_inv, mul_comm]` proof
 @[to_additive]
 theorem isUnit_iff_exists_inv' [CommMonoid M] {a : M} : IsUnit a ↔ ∃ b, b * a = 1 := by
-  rw [isUnit_iff_exists_inv]
-  simp [mul_comm]
+  simp [isUnit_iff_exists_inv, mul_comm]
 #align is_unit_iff_exists_inv' isUnit_iff_exists_inv'
 #align is_add_unit_iff_exists_neg' isAddUnit_iff_exists_neg'

perf: change to CommGroup instance on units (#6398)

Fixes a slowdown issue reported on Zulip. The first declaration in that example (the Basis example) takes 268578 to elaborate on master but only 11541 (an order of magnitude better) on this branch, and heartbeats no longer need to be bumped.

c5f2a158

Diff

@@ -198,8 +198,9 @@ attribute [instance] AddUnits.instAddGroupAddUnits
 @[to_additive "Additive units of an additive commutative monoid form
 an additive commutative group."]
 instance {α} [CommMonoid α] : CommGroup αˣ :=
-  { (inferInstance : Group αˣ) with
-    mul_comm := fun _ _ => ext <| mul_comm _ _ }
+  -- note: the original ported file had `{ (inferInstance : Group αˣ) with ... }`
+  -- and this was removed because it was causing slowdowns: see lean4#2387
+  { mul_comm := fun _ _ => ext <| mul_comm _ _ }
 attribute [instance] AddUnits.instAddCommGroupAddUnitsToAddMonoid
 #align units.comm_group Units.instCommGroupUnitsToMonoid
 #align add_units.add_comm_group AddUnits.instAddCommGroupAddUnitsToAddMonoid

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

89aa3a3b

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2017 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau, Mario Carneiro, Johannes Hölzl, Chris Hughes, Jens Wagemaker, Jon Eugster
-
-! This file was ported from Lean 3 source module algebra.group.units
-! leanprover-community/mathlib commit e8638a0fcaf73e4500469f368ef9494e495099b3
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Group.Basic
 import Mathlib.Logic.Nontrivial
 import Mathlib.Logic.Unique
 import Mathlib.Tactic.Nontriviality
 
+#align_import algebra.group.units from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"
+
 /-!
 # Units (i.e., invertible elements) of a monoid

refactor: move all register_simp_attrs to 1 file (#5681)

There are slight differences between mathlib3 and mathlib4 (different set of attributes, different lemmas are in core/std), so I redid the same refactor instead of forward-porting changes.

mathlib3 PR: leanprover-community/mathlib#19223

ceaa4ecb

Diff

@@ -600,8 +600,6 @@ theorem isUnit_of_subsingleton [Monoid M] [Subsingleton M] (a : M) : IsUnit a :=
 #align is_unit_of_subsingleton isUnit_of_subsingleton
 #align is_add_unit_of_subsingleton isAddUnit_of_subsingleton
 
-attribute [nontriviality] isAddUnit_of_subsingleton
-
 @[to_additive]
 instance [Monoid M] : CanLift M Mˣ Units.val IsUnit :=
   { prf := fun _ ↦ id }

chore: formatting issues (#4947)

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

5068808d

Diff

@@ -604,7 +604,7 @@ attribute [nontriviality] isAddUnit_of_subsingleton
 
 @[to_additive]
 instance [Monoid M] : CanLift M Mˣ Units.val IsUnit :=
-{ prf := fun _ ↦ id }
+  { prf := fun _ ↦ id }
 
 /-- A subsingleton `Monoid` has a unique unit. -/
 @[to_additive "A subsingleton `AddMonoid` has a unique additive unit."]

chore: fix many typos (#4967)

These are all doc fixes

6f9e51c3

Diff

@@ -214,7 +214,7 @@ instance : Inhabited αˣ :=
 attribute [instance] AddUnits.instInhabitedAddUnits
 
 /-- Units of a monoid have a representation of the base value in the `Monoid`. -/
-@[to_additive "Additive units of an addditive monoid have a representation of the base value in
+@[to_additive "Additive units of an additive monoid have a representation of the base value in
 the `AddMonoid`."]
 instance [Repr α] : Repr αˣ :=
   ⟨reprPrec ∘ val⟩

feat: port Algebra.CharP.MixedCharZero (#3222)

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

ab900bdd

Diff

@@ -132,7 +132,7 @@ theorem val_mk (a : α) (b h₁ h₂) : ↑(Units.mk a b h₁ h₂) = a :=
 #align add_units.coe_mk AddUnits.val_mk
 
 @[to_additive (attr := ext)]
-theorem ext : Function.Injective (fun (u : αˣ) => (u : α))
+theorem ext : Function.Injective (val : αˣ → α)
   | ⟨v, i₁, vi₁, iv₁⟩, ⟨v', i₂, vi₂, iv₂⟩, e => by
     simp only at e; subst v'; congr;
     simpa only [iv₂, vi₁, one_mul, mul_one] using mul_assoc i₂ v i₁

feat: add Mathlib.Tactic.Common, and import (#4056)

This makes a mathlib4 version of mathlib3's tactic.basic, now called Mathlib.Tactic.Common, which imports all tactics which do not have significant theory requirements, and then is imported all across the base of the hierarchy.

This ensures that all common tactics are available nearly everywhere in the library, rather than having to be imported one-by-one as you need them.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

a4eaf1c4

Diff

@@ -12,8 +12,6 @@ import Mathlib.Algebra.Group.Basic
 import Mathlib.Logic.Nontrivial
 import Mathlib.Logic.Unique
 import Mathlib.Tactic.Nontriviality
-import Mathlib.Tactic.Simps.Basic
-import Mathlib.Tactic.Lift
 
 /-!
 # Units (i.e., invertible elements) of a monoid

fix: add missing _root_ (#3630)

Mathport doesn't understand this, and apparently nor do many of the humans fixing the errors it creates.

If your #align statement complains the def doesn't exist, don't change the #align; work out why it doesn't exist instead.

Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

b7f71b0a

Diff

@@ -163,7 +163,7 @@ attribute [instance] AddUnits.instDecidableEqAddUnits
 theorem mk_val (u : αˣ) (y h₁ h₂) : mk (u : α) y h₁ h₂ = u :=
   ext rfl
 #align units.mk_coe Units.mk_val
-#align add_units.mk_coe Units.mk_val
+#align add_units.mk_coe AddUnits.mk_val
 
 /-- Copy a unit, adjusting definition equalities. -/
 @[to_additive (attr := simps) "Copy an `AddUnit`, adjusting definitional equalities."]

feat: port LinearAlgebra.Matrix.NonsingularInverse (#3647)

d8af7b4f

Diff

@@ -114,9 +114,9 @@ attribute [instance] AddUnits.instCoeHeadAddUnits
 
 /-- The inverse of a unit in a `Monoid`. -/
 @[to_additive "The additive inverse of an additive unit in an `AddMonoid`."]
-instance : Inv αˣ :=
+instance instInv : Inv αˣ :=
   ⟨fun u => ⟨u.2, u.1, u.4, u.3⟩⟩
-attribute [instance] AddUnits.instNegAddUnits
+attribute [instance] AddUnits.instNeg
 
 /- porting note: the result of these definitions is syntactically equal to `Units.val` and
 `Units.inv` because of the way coercions work in Lean 4, so there is no need for these custom

chore: fix #align lines (#3640)

This PR fixes two things:

Most align statements for definitions and theorems and instances that are separated by two newlines from the relevant declaration (s/\n\n#align/\n#align). This is often seen in the mathport output after ending calc blocks.
All remaining more-than-one-line #align statements. (This was needed for a script I wrote for #3630.)

2b42dc7c

Diff

@@ -139,7 +139,6 @@ theorem ext : Function.Injective (fun (u : αˣ) => (u : α))
     simp only at e; subst v'; congr;
     simpa only [iv₂, vi₁, one_mul, mul_one] using mul_assoc i₂ v i₁
 #align units.ext Units.ext
-
 #align add_units.ext AddUnits.ext
 
 @[to_additive (attr := norm_cast)]

feat: Dot notation aliases (#3303)

Match https://github.com/leanprover-community/mathlib/pull/18698 and a bit of https://github.com/leanprover-community/mathlib/pull/18785.

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>

4fa401fa

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau, Mario Carneiro, Johannes Hölzl, Chris Hughes, Jens Wagemaker, Jon Eugster
 
 ! This file was ported from Lean 3 source module algebra.group.units
-! leanprover-community/mathlib commit 369525b73f229ccd76a6ec0e0e0bf2be57599768
+! leanprover-community/mathlib commit e8638a0fcaf73e4500469f368ef9494e495099b3
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -552,6 +552,28 @@ theorem divp_mul_divp (x y : α) (ux uy : αˣ) : x /ₚ ux * (y /ₚ uy) = x *
   rw [divp_mul_eq_mul_divp, divp_assoc', divp_divp_eq_divp_mul]
 #align divp_mul_divp divp_mul_divp
 
+variable [Subsingleton αˣ] {a b : α}
+
+@[to_additive]
+theorem eq_one_of_mul_right (h : a * b = 1) : a = 1 :=
+  congr_arg Units.inv <| Subsingleton.elim (Units.mk _ _ (by rwa [mul_comm]) h) 1
+#align eq_one_of_mul_right eq_one_of_mul_right
+#align eq_zero_of_add_right eq_zero_of_add_right
+
+@[to_additive]
+theorem eq_one_of_mul_left (h : a * b = 1) : b = 1 :=
+  congr_arg Units.inv <| Subsingleton.elim (Units.mk _ _ h <| by rwa [mul_comm]) 1
+#align eq_one_of_mul_left eq_one_of_mul_left
+#align eq_zero_of_add_left eq_zero_of_add_left
+
+@[to_additive (attr := simp)]
+theorem mul_eq_one : a * b = 1 ↔ a = 1 ∧ b = 1 :=
+  ⟨fun h => ⟨eq_one_of_mul_right h, eq_one_of_mul_left h⟩, by
+    rintro ⟨rfl, rfl⟩
+    exact mul_one _⟩
+#align mul_eq_one mul_eq_one
+#align add_eq_zero add_eq_zero
+
 end CommMonoid
 
 /-!

feat: add to_additive linter checking whether additive decl exists (#1881)

Force the user to specify whether the additive declaration already exists.
Will raise a linter error if the user specified it wrongly
Requested on Zulip

77e63150

Diff

@@ -712,7 +712,7 @@ protected noncomputable def _root_.IsAddUnit.addUnit [AddMonoid N] {a : N} (h :
     AddUnits N :=
   (Classical.choose h).copy a (Classical.choose_spec h).symm _ rfl
 #align is_add_unit.add_unit IsAddUnit.addUnit
-attribute [to_additive] IsUnit.unit
+attribute [to_additive existing] IsUnit.unit
 
 @[to_additive (attr := simp)]
 theorem unit_of_val_units {a : Mˣ} (h : IsUnit (a : M)) : h.unit = a :=

chore: update hash for Group/Units for is_add_unit.decidable (#2278)

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

14dc1993

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau, Mario Carneiro, Johannes Hölzl, Chris Hughes, Jens Wagemaker, Jon Eugster
 
 ! This file was ported from Lean 3 source module algebra.group.units
-! leanprover-community/mathlib commit 0f601d095cdfe465edc51882323d19e6b333c419
+! leanprover-community/mathlib commit 369525b73f229ccd76a6ec0e0e0bf2be57599768
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -739,7 +739,7 @@ theorem mul_val_inv (h : IsUnit a) : a * ↑h.unit⁻¹ = 1 := by
 #align is_add_unit.add_coe_neg IsAddUnit.add_val_neg
 
 /-- `IsUnit x` is decidable if we can decide if `x` comes from `Mˣ`. -/
-@[to_additive]
+@[to_additive "`IsAddUnit x` is decidable if we can decide if `x` comes from `AddUnits M`."]
 instance (x : M) [h : Decidable (∃ u : Mˣ, ↑u = x)] : Decidable (IsUnit x) :=
   h
 attribute [instance] IsAddUnit.instDecidableIsAddUnit

feat: port LinearAlgebra.Span (#2248)

Co-authored-by: Johan Commelin <johan@commelin.net> Co-authored-by: qawbecrdtey <qawbecrdtey@naver.com>

336884cd

Diff

@@ -13,6 +13,7 @@ import Mathlib.Logic.Nontrivial
 import Mathlib.Logic.Unique
 import Mathlib.Tactic.Nontriviality
 import Mathlib.Tactic.Simps.Basic
+import Mathlib.Tactic.Lift
 
 /-!
 # Units (i.e., invertible elements) of a monoid
@@ -582,7 +583,9 @@ theorem isUnit_of_subsingleton [Monoid M] [Subsingleton M] (a : M) : IsUnit a :=
 
 attribute [nontriviality] isAddUnit_of_subsingleton
 
--- Porting note: removing the `CanLift` instance
+@[to_additive]
+instance [Monoid M] : CanLift M Mˣ Units.val IsUnit :=
+{ prf := fun _ ↦ id }
 
 /-- A subsingleton `Monoid` has a unique unit. -/
 @[to_additive "A subsingleton `AddMonoid` has a unique additive unit."]

feat: port field_simp tactic (#1824)

Ports the field_simp tactic and tests from mathlib3.
Adds a new test taken from minif2f (but with rats instead of reals, for simplicity): https://github.com/openai/miniF2F/blob/4e433ff5cadff23f9911a2bb5bbab2d351ce5554/lean/src/valid.lean#L524-L530.
Uses field_simp in two already-ported files, as directed by port notes.
Adds an explicit priority to a few field_simps lemmas. This is necessary to make all of the examples work.

55ad1be0

Diff

@@ -485,7 +485,9 @@ theorem divp_divp_eq_divp_mul (x : α) (u₁ u₂ : αˣ) : x /ₚ u₁ /ₚ u
   simp only [divp, mul_inv_rev, Units.val_mul, mul_assoc]
 #align divp_divp_eq_divp_mul divp_divp_eq_divp_mul
 
-@[field_simps]
+/- Port note: to match the mathlib3 behavior, this needs to have higher simp
+priority than eq_divp_iff_mul_eq. -/
+@[field_simps 1010]
 theorem divp_eq_iff_mul_eq {x : α} {u : αˣ} {y : α} : x /ₚ u = y ↔ y * u = x :=
   u.mul_left_inj.symm.trans <| by rw [divp_mul_cancel]; exact ⟨Eq.symm, Eq.symm⟩
 #align divp_eq_iff_mul_eq divp_eq_iff_mul_eq

fix: use to_additive (attr := _) here and there (#2073)

adaaf293

Diff

@@ -166,7 +166,7 @@ theorem mk_val (u : αˣ) (y h₁ h₂) : mk (u : α) y h₁ h₂ = u :=
 #align add_units.mk_coe Units.mk_val
 
 /-- Copy a unit, adjusting definition equalities. -/
-@[to_additive "Copy an `AddUnit`, adjusting definitional equalities.", simps]
+@[to_additive (attr := simps) "Copy an `AddUnit`, adjusting definitional equalities."]
 def copy (u : αˣ) (val : α) (hv : val = u) (inv : α) (hi : inv = ↑u⁻¹) : αˣ :=
   { val, inv, inv_val := hv.symm ▸ hi.symm ▸ u.inv_val, val_inv := hv.symm ▸ hi.symm ▸ u.val_inv }
 #align units.copy Units.copy

chore: add missing #align statements (#1902)

This PR is the result of a slight variant on the following "algorithm"

take all mathlib 3 names, remove _ and make all uppercase letters into lowercase
take all mathlib 4 names, remove _ and make all uppercase letters into lowercase
look for matches, and create pairs (original_lean3_name, OriginalLean4Name)
for pairs that do not have an align statement:
- use Lean 4 to lookup the file + position of the Lean 4 name
- add an #align statement just before the next empty line
manually fix some tiny mistakes (e.g., empty lines in proofs might cause the #align statement to have been inserted too early)

b72bb858

Diff

@@ -310,27 +310,39 @@ theorem inv_mul_cancel_right (a : α) (b : αˣ) : a * ↑b⁻¹ * b = a := by
 theorem mul_right_inj (a : αˣ) {b c : α} : (a : α) * b = a * c ↔ b = c :=
   ⟨fun h => by simpa only [inv_mul_cancel_left] using congr_arg (fun x : α => ↑(a⁻¹ : αˣ) * x) h,
     congr_arg _⟩
+#align units.mul_right_inj Units.mul_right_inj
+#align add_units.add_right_inj AddUnits.add_right_inj
 
 @[to_additive (attr := simp)]
 theorem mul_left_inj (a : αˣ) {b c : α} : b * a = c * a ↔ b = c :=
   ⟨fun h => by simpa only [mul_inv_cancel_right] using congr_arg (fun x : α => x * ↑(a⁻¹ : αˣ)) h,
     congr_arg (· * a.val)⟩
+#align units.mul_left_inj Units.mul_left_inj
+#align add_units.add_left_inj AddUnits.add_left_inj
 
 @[to_additive]
 theorem eq_mul_inv_iff_mul_eq {a b : α} : a = b * ↑c⁻¹ ↔ a * c = b :=
   ⟨fun h => by rw [h, inv_mul_cancel_right], fun h => by rw [← h, mul_inv_cancel_right]⟩
+#align units.eq_mul_inv_iff_mul_eq Units.eq_mul_inv_iff_mul_eq
+#align add_units.eq_add_neg_iff_add_eq AddUnits.eq_add_neg_iff_add_eq
 
 @[to_additive]
 theorem eq_inv_mul_iff_mul_eq {a c : α} : a = ↑b⁻¹ * c ↔ ↑b * a = c :=
   ⟨fun h => by rw [h, mul_inv_cancel_left], fun h => by rw [← h, inv_mul_cancel_left]⟩
+#align units.eq_inv_mul_iff_mul_eq Units.eq_inv_mul_iff_mul_eq
+#align add_units.eq_neg_add_iff_add_eq AddUnits.eq_neg_add_iff_add_eq
 
 @[to_additive]
 theorem inv_mul_eq_iff_eq_mul {b c : α} : ↑a⁻¹ * b = c ↔ b = a * c :=
   ⟨fun h => by rw [← h, mul_inv_cancel_left], fun h => by rw [h, inv_mul_cancel_left]⟩
+#align units.inv_mul_eq_iff_eq_mul Units.inv_mul_eq_iff_eq_mul
+#align add_units.neg_add_eq_iff_eq_add AddUnits.neg_add_eq_iff_eq_add
 
 @[to_additive]
 theorem mul_inv_eq_iff_eq_mul {a c : α} : a * ↑b⁻¹ = c ↔ a = c * b :=
   ⟨fun h => by rw [← h, inv_mul_cancel_right], fun h => by rw [h, mul_inv_cancel_right]⟩
+#align units.mul_inv_eq_iff_eq_mul Units.mul_inv_eq_iff_eq_mul
+#align add_units.add_neg_eq_iff_eq_add AddUnits.add_neg_eq_iff_eq_add
 
 -- Porting note: have to explicitly type annotate the 1
 @[to_additive]
@@ -338,6 +350,8 @@ protected theorem inv_eq_of_mul_eq_one_left {a : α} (h : a * u = 1) : ↑u⁻¹
   calc
     ↑u⁻¹ = (1 : α) * ↑u⁻¹ := by rw [one_mul]
     _ = a := by rw [← h, mul_inv_cancel_right]
+#align units.inv_eq_of_mul_eq_one_left Units.inv_eq_of_mul_eq_one_left
+#align add_units.neg_eq_of_add_eq_zero_left AddUnits.neg_eq_of_add_eq_zero_left
 
 
 -- Porting note: have to explicitly type annotate the 1
@@ -346,33 +360,49 @@ protected theorem inv_eq_of_mul_eq_one_right {a : α} (h : ↑u * a = 1) : ↑u
   calc
     ↑u⁻¹ = ↑u⁻¹ * (1 : α) := by rw [mul_one]
     _ = a := by rw [← h, inv_mul_cancel_left]
+#align units.inv_eq_of_mul_eq_one_right Units.inv_eq_of_mul_eq_one_right
+#align add_units.neg_eq_of_add_eq_zero_right AddUnits.neg_eq_of_add_eq_zero_right
 
 
 @[to_additive]
 protected theorem eq_inv_of_mul_eq_one_left {a : α} (h : ↑u * a = 1) : a = ↑u⁻¹ :=
   (Units.inv_eq_of_mul_eq_one_right h).symm
+#align units.eq_inv_of_mul_eq_one_left Units.eq_inv_of_mul_eq_one_left
+#align add_units.eq_neg_of_add_eq_zero_left AddUnits.eq_neg_of_add_eq_zero_left
 
 @[to_additive]
 protected theorem eq_inv_of_mul_eq_one_right {a : α} (h : a * u = 1) : a = ↑u⁻¹ :=
   (Units.inv_eq_of_mul_eq_one_left h).symm
+#align units.eq_inv_of_mul_eq_one_right Units.eq_inv_of_mul_eq_one_right
+#align add_units.eq_neg_of_add_eq_zero_right AddUnits.eq_neg_of_add_eq_zero_right
 
 @[to_additive (attr := simp)]
 theorem mul_inv_eq_one {a : α} : a * ↑u⁻¹ = 1 ↔ a = u :=
   ⟨inv_inv u ▸ Units.eq_inv_of_mul_eq_one_right, fun h => mul_inv_of_eq h.symm⟩
+#align units.mul_inv_eq_one Units.mul_inv_eq_one
+#align add_units.add_neg_eq_zero AddUnits.add_neg_eq_zero
 
 @[to_additive (attr := simp)]
 theorem inv_mul_eq_one {a : α} : ↑u⁻¹ * a = 1 ↔ ↑u = a :=
   ⟨inv_inv u ▸ Units.inv_eq_of_mul_eq_one_right, inv_mul_of_eq⟩
+#align units.inv_mul_eq_one Units.inv_mul_eq_one
+#align add_units.neg_add_eq_zero AddUnits.neg_add_eq_zero
 
 @[to_additive]
 theorem mul_eq_one_iff_eq_inv {a : α} : a * u = 1 ↔ a = ↑u⁻¹ := by rw [← mul_inv_eq_one, inv_inv]
+#align units.mul_eq_one_iff_eq_inv Units.mul_eq_one_iff_eq_inv
+#align add_units.add_eq_zero_iff_eq_neg AddUnits.add_eq_zero_iff_eq_neg
 
 @[to_additive]
 theorem mul_eq_one_iff_inv_eq {a : α} : ↑u * a = 1 ↔ ↑u⁻¹ = a := by rw [← inv_mul_eq_one, inv_inv]
+#align units.mul_eq_one_iff_inv_eq Units.mul_eq_one_iff_inv_eq
+#align add_units.add_eq_zero_iff_neg_eq AddUnits.add_eq_zero_iff_neg_eq
 
 @[to_additive]
 theorem inv_unique {u₁ u₂ : αˣ} (h : (↑u₁ : α) = ↑u₂) : (↑u₁⁻¹ : α) = ↑u₂⁻¹ :=
   Units.inv_eq_of_mul_eq_one_right <| by rw [h, u₂.mul_inv]
+#align units.inv_unique Units.inv_unique
+#align add_units.neg_unique AddUnits.neg_unique
 
 @[to_additive (attr := simp)]
 theorem val_inv_eq_inv_val {M : Type _} [DivisionMonoid M] (u : Units M) : ↑u⁻¹ = (u⁻¹ : M) :=
@@ -386,6 +416,8 @@ end Units
   "For `a, b` in an `AddCommMonoid` such that `a + b = 0`, makes an add_unit out of `a`."]
 def Units.mkOfMulEqOne [CommMonoid α] (a b : α) (hab : a * b = 1) : αˣ :=
   ⟨a, b, hab, (mul_comm b a).trans hab⟩
+#align units.mk_of_mul_eq_one Units.mkOfMulEqOne
+#align add_units.mk_of_add_eq_zero AddUnits.mkOfAddEqZero
 
 @[to_additive (attr := simp)]
 theorem Units.val_mkOfMulEqOne [CommMonoid α] {a b : α} (h : a * b = 1) :
@@ -403,6 +435,7 @@ variable [Monoid α] {a b c : α}
   in `DivisionRing` it is not totalized at zero. -/
 def divp (a : α) (u : Units α) : α :=
   a * (u⁻¹ : αˣ)
+#align divp divp
 
 @[inherit_doc]
 infixl:70 " /ₚ " => divp
@@ -410,57 +443,71 @@ infixl:70 " /ₚ " => divp
 @[simp]
 theorem divp_self (u : αˣ) : (u : α) /ₚ u = 1 :=
   Units.mul_inv _
+#align divp_self divp_self
 
 @[simp]
 theorem divp_one (a : α) : a /ₚ 1 = a :=
   mul_one _
+#align divp_one divp_one
 
 theorem divp_assoc (a b : α) (u : αˣ) : a * b /ₚ u = a * (b /ₚ u) :=
   mul_assoc _ _ _
+#align divp_assoc divp_assoc
 
 /-- `field_simp` needs the reverse direction of `divp_assoc` to move all `/ₚ` to the right. -/
 @[field_simps]
 theorem divp_assoc' (x y : α) (u : αˣ) : x * (y /ₚ u) = x * y /ₚ u :=
   (divp_assoc _ _ _).symm
+#align divp_assoc' divp_assoc'
 
 @[simp]
 theorem divp_inv (u : αˣ) : a /ₚ u⁻¹ = a * u :=
   rfl
+#align divp_inv divp_inv
 
 @[simp]
 theorem divp_mul_cancel (a : α) (u : αˣ) : a /ₚ u * u = a :=
   (mul_assoc _ _ _).trans <| by rw [Units.inv_mul, mul_one]
+#align divp_mul_cancel divp_mul_cancel
 
 @[simp]
 theorem mul_divp_cancel (a : α) (u : αˣ) : a * u /ₚ u = a :=
   (mul_assoc _ _ _).trans <| by rw [Units.mul_inv, mul_one]
+#align mul_divp_cancel mul_divp_cancel
 
 @[simp]
 theorem divp_left_inj (u : αˣ) {a b : α} : a /ₚ u = b /ₚ u ↔ a = b :=
   Units.mul_left_inj _
+#align divp_left_inj divp_left_inj
 
 @[field_simps]
 theorem divp_divp_eq_divp_mul (x : α) (u₁ u₂ : αˣ) : x /ₚ u₁ /ₚ u₂ = x /ₚ (u₂ * u₁) := by
   simp only [divp, mul_inv_rev, Units.val_mul, mul_assoc]
+#align divp_divp_eq_divp_mul divp_divp_eq_divp_mul
 
 @[field_simps]
 theorem divp_eq_iff_mul_eq {x : α} {u : αˣ} {y : α} : x /ₚ u = y ↔ y * u = x :=
   u.mul_left_inj.symm.trans <| by rw [divp_mul_cancel]; exact ⟨Eq.symm, Eq.symm⟩
+#align divp_eq_iff_mul_eq divp_eq_iff_mul_eq
 
 @[field_simps]
 theorem eq_divp_iff_mul_eq {x : α} {u : αˣ} {y : α} : x = y /ₚ u ↔ x * u = y := by
   rw [eq_comm, divp_eq_iff_mul_eq]
+#align eq_divp_iff_mul_eq eq_divp_iff_mul_eq
 
 theorem divp_eq_one_iff_eq {a : α} {u : αˣ} : a /ₚ u = 1 ↔ a = u :=
   (Units.mul_left_inj u).symm.trans <| by rw [divp_mul_cancel, one_mul]
+#align divp_eq_one_iff_eq divp_eq_one_iff_eq
 
 @[simp]
 theorem one_divp (u : αˣ) : 1 /ₚ u = ↑u⁻¹ :=
   one_mul _
+#align one_divp one_divp
 
 /-- Used for `field_simp` to deal with inverses of units. -/
 @[field_simps]
 theorem inv_eq_one_divp (u : αˣ) : ↑u⁻¹ = 1 /ₚ u := by rw [one_divp]
+#align inv_eq_one_divp inv_eq_one_divp
 
 /-- Used for `field_simp` to deal with inverses of units. This form of the lemma
 is essential since `field_simp` likes to use `inv_eq_one_div` to rewrite
@@ -469,6 +516,7 @@ is essential since `field_simp` likes to use `inv_eq_one_div` to rewrite
 @[field_simps]
 theorem inv_eq_one_divp' (u : αˣ) : ((1 / u : αˣ) : α) = 1 /ₚ u := by
   rw [one_div, one_divp]
+#align inv_eq_one_divp' inv_eq_one_divp'
 
 /-- `field_simp` moves division inside `αˣ` to the right, and this lemma
 lifts the calculation to `α`.
@@ -487,16 +535,19 @@ variable [CommMonoid α]
 @[field_simps]
 theorem divp_mul_eq_mul_divp (x y : α) (u : αˣ) : x /ₚ u * y = x * y /ₚ u := by
   rw [divp, divp, mul_right_comm]
+#align divp_mul_eq_mul_divp divp_mul_eq_mul_divp
 
 -- Theoretically redundant as `field_simp` lemma.
 @[field_simps]
 theorem divp_eq_divp_iff {x y : α} {ux uy : αˣ} : x /ₚ ux = y /ₚ uy ↔ x * uy = y * ux := by
   rw [divp_eq_iff_mul_eq, divp_mul_eq_mul_divp, divp_eq_iff_mul_eq]
+#align divp_eq_divp_iff divp_eq_divp_iff
 
 -- Theoretically redundant as `field_simp` lemma.
 @[field_simps]
 theorem divp_mul_divp (x y : α) (ux uy : αˣ) : x /ₚ ux * (y /ₚ uy) = x * y /ₚ (ux * uy) := by
   rw [divp_mul_eq_mul_divp, divp_assoc', divp_divp_eq_divp_mul]
+#align divp_mul_divp divp_mul_divp
 
 end CommMonoid
 
@@ -518,6 +569,8 @@ The actual definition says that `a` is equal to some `u : Mˣ`, where
       where `AddUnits M` is a bundled version of `IsAddUnit`."]
 def IsUnit [Monoid M] (a : M) : Prop :=
   ∃ u : Mˣ, (u : M) = a
+#align is_unit IsUnit
+#align is_add_unit IsAddUnit
 
 @[to_additive (attr := nontriviality)]
 theorem isUnit_of_subsingleton [Monoid M] [Subsingleton M] (a : M) : IsUnit a :=
@@ -558,11 +611,15 @@ theorem isUnit_of_mul_eq_one [CommMonoid M] (a b : M) (h : a * b = 1) : IsUnit a
 theorem IsUnit.exists_right_inv [Monoid M] {a : M} (h : IsUnit a) : ∃ b, a * b = 1 := by
   rcases h with ⟨⟨a, b, hab, _⟩, rfl⟩
   exact ⟨b, hab⟩
+#align is_unit.exists_right_inv IsUnit.exists_right_inv
+#align is_add_unit.exists_neg IsAddUnit.exists_neg
 
 @[to_additive IsAddUnit.exists_neg']
 theorem IsUnit.exists_left_inv [Monoid M] {a : M} (h : IsUnit a) : ∃ b, b * a = 1 := by
   rcases h with ⟨⟨a, b, _, hba⟩, rfl⟩
   exact ⟨b, hba⟩
+#align is_unit.exists_left_inv IsUnit.exists_left_inv
+#align is_add_unit.exists_neg' IsAddUnit.exists_neg'
 
 @[to_additive]
 theorem isUnit_iff_exists_inv [CommMonoid M] {a : M} : IsUnit a ↔ ∃ b, a * b = 1 :=
@@ -582,6 +639,8 @@ theorem isUnit_iff_exists_inv' [CommMonoid M] {a : M} : IsUnit a ↔ ∃ b, b *
 theorem IsUnit.mul [Monoid M] {x y : M} : IsUnit x → IsUnit y → IsUnit (x * y) := by
   rintro ⟨x, rfl⟩ ⟨y, rfl⟩
   exact ⟨x * y, Units.val_mul _ _⟩
+#align is_unit.mul IsUnit.mul
+#align is_add_unit.add IsAddUnit.add
 
 /-- Multiplication by a `u : Mˣ` on the right doesn't affect `IsUnit`. -/
 @[to_additive (attr := simp)
@@ -659,6 +718,8 @@ theorem unit_of_val_units {a : Mˣ} (h : IsUnit (a : M)) : h.unit = a :=
 @[to_additive (attr := simp)]
 theorem unit_spec (h : IsUnit a) : ↑h.unit = a :=
   rfl
+#align is_unit.unit_spec IsUnit.unit_spec
+#align is_add_unit.add_unit_spec IsAddUnit.addUnit_spec
 
 @[to_additive (attr := simp)]
 theorem val_inv_mul (h : IsUnit a) : ↑h.unit⁻¹ * a = 1 :=
@@ -682,27 +743,39 @@ attribute [instance] IsAddUnit.instDecidableIsAddUnit
 theorem mul_left_inj (h : IsUnit a) : b * a = c * a ↔ b = c :=
   let ⟨u, hu⟩ := h
   hu ▸ u.mul_left_inj
+#align is_unit.mul_left_inj IsUnit.mul_left_inj
+#align is_add_unit.add_left_inj IsAddUnit.add_left_inj
 
 @[to_additive]
 theorem mul_right_inj (h : IsUnit a) : a * b = a * c ↔ b = c :=
   let ⟨u, hu⟩ := h
   hu ▸ u.mul_right_inj
+#align is_unit.mul_right_inj IsUnit.mul_right_inj
+#align is_add_unit.add_right_inj IsAddUnit.add_right_inj
 
 @[to_additive]
 protected theorem mul_left_cancel (h : IsUnit a) : a * b = a * c → b = c :=
   h.mul_right_inj.1
+#align is_unit.mul_left_cancel IsUnit.mul_left_cancel
+#align is_add_unit.add_left_cancel IsAddUnit.add_left_cancel
 
 @[to_additive]
 protected theorem mul_right_cancel (h : IsUnit b) : a * b = c * b → a = c :=
   h.mul_left_inj.1
+#align is_unit.mul_right_cancel IsUnit.mul_right_cancel
+#align is_add_unit.add_right_cancel IsAddUnit.add_right_cancel
 
 @[to_additive]
 protected theorem mul_right_injective (h : IsUnit a) : Injective ((· * ·) a) :=
   fun _ _ => h.mul_left_cancel
+#align is_unit.mul_right_injective IsUnit.mul_right_injective
+#align is_add_unit.add_right_injective IsAddUnit.add_right_injective
 
 @[to_additive]
 protected theorem mul_left_injective (h : IsUnit b) : Injective (· * b) :=
   fun _ _ => h.mul_right_cancel
+#align is_unit.mul_left_injective IsUnit.mul_left_injective
+#align is_add_unit.add_left_injective IsAddUnit.add_left_injective
 
 end Monoid
 
@@ -712,11 +785,15 @@ variable [DivisionMonoid M] {a : M}
 protected theorem inv_mul_cancel : IsUnit a → a⁻¹ * a = 1 := by
   rintro ⟨u, rfl⟩
   rw [← Units.val_inv_eq_inv_val, Units.inv_mul]
+#align is_unit.inv_mul_cancel IsUnit.inv_mul_cancel
+#align is_add_unit.neg_add_cancel IsAddUnit.neg_add_cancel
 
 @[to_additive (attr := simp)]
 protected theorem mul_inv_cancel : IsUnit a → a * a⁻¹ = 1 := by
   rintro ⟨u, rfl⟩
   rw [← Units.val_inv_eq_inv_val, Units.mul_inv]
+#align is_unit.mul_inv_cancel IsUnit.mul_inv_cancel
+#align is_add_unit.add_neg_cancel IsAddUnit.add_neg_cancel
 
 end IsUnit

chore: add #align statements for to_additive decls (#1816)

Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com>

ed378238

Diff

@@ -96,6 +96,7 @@ section HasElem
 theorem unique_one {α : Type _} [Unique α] [One α] : default = (1 : α) :=
   Unique.default_eq 1
 #align unique_has_one unique_one
+#align unique_has_zero unique_zero
 
 end HasElem
 
@@ -391,6 +392,7 @@ theorem Units.val_mkOfMulEqOne [CommMonoid α] {a b : α} (h : a * b = 1) :
     (Units.mkOfMulEqOne a b h : α) = a :=
   rfl
 #align units.coe_mk_of_mul_eq_one Units.val_mkOfMulEqOne
+#align add_units.coe_mk_of_add_eq_zero AddUnits.val_mkOfAddEqZero
 
 section Monoid

chore: fix most phantom #aligns (#1794)

3d3fb046

Diff

@@ -538,7 +538,7 @@ instance [Monoid M] [Subsingleton M] : Unique Mˣ where
 protected theorem Units.isUnit [Monoid M] (u : Mˣ) : IsUnit (u : M) :=
   ⟨u, rfl⟩
 #align units.is_unit Units.isUnit
-#align is_add_unit_add_unit AddUnits.isAddUnit
+#align add_units.is_add_unit_add_unit AddUnits.isAddUnit
 
 @[to_additive (attr := simp)]
 theorem isUnit_one [Monoid M] : IsUnit (1 : M) :=
@@ -604,20 +604,20 @@ theorem Units.isUnit_units_mul {M : Type _} [Monoid M] (u : Mˣ) (a : M) :
       rwa [← mul_assoc, Units.inv_mul, one_mul] at this)
     u.isUnit.mul
 #align units.is_unit_units_mul Units.isUnit_units_mul
-#align add_units.is_add_unit_units_add AddUnits.isAddUnit_addUnits_add
+#align add_units.is_add_unit_add_units_add AddUnits.isAddUnit_addUnits_add
 
 @[to_additive]
 theorem isUnit_of_mul_isUnit_left [CommMonoid M] {x y : M} (hu : IsUnit (x * y)) : IsUnit x :=
   let ⟨z, hz⟩ := isUnit_iff_exists_inv.1 hu
   isUnit_iff_exists_inv.2 ⟨y * z, by rwa [← mul_assoc]⟩
 #align is_unit_of_mul_is_unit_left isUnit_of_mul_isUnit_left
-#align is_add_unit_of_add_is_unit_left isAddUnit_of_add_isAddUnit_left
+#align is_add_unit_of_add_is_add_unit_left isAddUnit_of_add_isAddUnit_left
 
 @[to_additive]
 theorem isUnit_of_mul_isUnit_right [CommMonoid M] {x y : M} (hu : IsUnit (x * y)) : IsUnit y :=
   @isUnit_of_mul_isUnit_left _ _ y x <| by rwa [mul_comm]
 #align is_unit_of_mul_is_unit_right isUnit_of_mul_isUnit_right
-#align is_add_unit_of_add_is_unit_right isAddUnit_of_add_isAddUnit_right
+#align is_add_unit_of_add_is_add_unit_right isAddUnit_of_add_isAddUnit_right
 
 namespace IsUnit
 
@@ -652,7 +652,7 @@ attribute [to_additive] IsUnit.unit
 theorem unit_of_val_units {a : Mˣ} (h : IsUnit (a : M)) : h.unit = a :=
   Units.ext <| rfl
 #align is_unit.unit_of_coe_units IsUnit.unit_of_val_units
-#align is_add_unit.unit_of_coe_units IsAddUnit.addUnit_of_val_addUnits
+#align is_add_unit.add_unit_of_coe_add_units IsAddUnit.addUnit_of_val_addUnits
 
 @[to_additive (attr := simp)]
 theorem unit_spec (h : IsUnit a) : ↑h.unit = a :=

chore: tidy various files (#1595)

6fe10b88

Diff

@@ -583,7 +583,7 @@ theorem IsUnit.mul [Monoid M] {x y : M} : IsUnit x → IsUnit y → IsUnit (x *
 
 /-- Multiplication by a `u : Mˣ` on the right doesn't affect `IsUnit`. -/
 @[to_additive (attr := simp)
-"Addition of a `u : add_units M` on the right doesn't affect `IsAddUnit`."]
+"Addition of a `u : AddUnits M` on the right doesn't affect `IsAddUnit`."]
 theorem Units.isUnit_mul_units [Monoid M] (a : M) (u : Mˣ) : IsUnit (a * u) ↔ IsUnit a :=
   Iff.intro
     (fun ⟨v, hv⟩ => by
@@ -595,7 +595,7 @@ theorem Units.isUnit_mul_units [Monoid M] (a : M) (u : Mˣ) : IsUnit (a * u) ↔
 
 /-- Multiplication by a `u : Mˣ` on the left doesn't affect `IsUnit`. -/
 @[to_additive (attr := simp)
-"Addition of a `u : add_units M` on the left doesn't affect `IsAddUnit`."]
+"Addition of a `u : AddUnits M` on the left doesn't affect `IsAddUnit`."]
 theorem Units.isUnit_units_mul {M : Type _} [Monoid M] (u : Mˣ) (a : M) :
     IsUnit (↑u * a) ↔ IsUnit a :=
   Iff.intro

feat: improve the way to_additive deals with attributes (#1314)

The new syntax for any attributes that need to be copied by to_additive is @[to_additive (attrs := simp, ext, simps)]
Adds the auxiliary declarations generated by the simp and simps attributes to the to_additive-dictionary.
Future issue: Does not yet translate auxiliary declarations for other attributes (including custom simp-attributes). In particular it's possible that norm_cast might generate some auxiliary declarations.
Fixes #950
Fixes #953
Fixes #1149
This moves the interaction between to_additive and simps from the Simps file to the toAdditive file for uniformity.
Make the same changes to @[reassoc]

Co-authored-by: Johan Commelin <johan@commelin.net> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

56bf4cd6

Diff

@@ -131,7 +131,7 @@ theorem val_mk (a : α) (b h₁ h₂) : ↑(Units.mk a b h₁ h₂) = a :=
 #align units.coe_mk Units.val_mk
 #align add_units.coe_mk AddUnits.val_mk
 
-@[ext, to_additive]
+@[to_additive (attr := ext)]
 theorem ext : Function.Injective (fun (u : αˣ) => (u : α))
   | ⟨v, i₁, vi₁, iv₁⟩, ⟨v', i₂, vi₂, iv₂⟩, e => by
     simp only at e; subst v'; congr;
@@ -140,7 +140,7 @@ theorem ext : Function.Injective (fun (u : αˣ) => (u : α))
 
 #align add_units.ext AddUnits.ext
 
-@[norm_cast, to_additive]
+@[to_additive (attr := norm_cast)]
 theorem eq_iff {a b : αˣ} : (a : α) = b ↔ a = b :=
   ext.eq_iff
 #align units.eq_iff Units.eq_iff
@@ -158,7 +158,7 @@ if the base `AddMonoid` has deciable equality."]
 instance [DecidableEq α] : DecidableEq αˣ := fun _ _ => decidable_of_iff' _ ext_iff
 attribute [instance] AddUnits.instDecidableEqAddUnits
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mk_val (u : αˣ) (y h₁ h₂) : mk (u : α) y h₁ h₂ = u :=
   ext rfl
 #align units.mk_coe Units.mk_val
@@ -223,24 +223,24 @@ attribute [instance] AddUnits.instReprAddUnits
 
 variable (a b c : αˣ) {u : αˣ}
 
-@[simp, norm_cast, to_additive]
+@[to_additive (attr := simp, norm_cast)]
 theorem val_mul : (↑(a * b) : α) = a * b :=
   rfl
 #align units.coe_mul Units.val_mul
 #align add_units.coe_add AddUnits.val_add
 
-@[simp, norm_cast, to_additive]
+@[to_additive (attr := simp, norm_cast)]
 theorem val_one : ((1 : αˣ) : α) = 1 :=
   rfl
 #align units.coe_one Units.val_one
 #align add_units.coe_zero AddUnits.val_zero
 
-@[simp, norm_cast, to_additive]
+@[to_additive (attr := simp, norm_cast)]
 theorem val_eq_one {a : αˣ} : (a : α) = 1 ↔ a = 1 := by rw [← Units.val_one, eq_iff]
 #align units.coe_eq_one Units.val_eq_one
 #align add_units.coe_eq_zero AddUnits.val_eq_zero
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem inv_mk (x y : α) (h₁ h₂) : (mk x y h₁ h₂)⁻¹ = mk y x h₂ h₁ :=
   rfl
 #align units.inv_mk Units.inv_mk
@@ -259,13 +259,13 @@ attribute [simp 900] Units.inv_eq_val_inv AddUnits.neg_eq_val_neg
 #align units.inv_eq_coe_inv Units.inv_eq_val_inv
 #align add_units.neg_eq_coe_neg AddUnits.neg_eq_val_neg
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem inv_mul : (↑a⁻¹ * a : α) = 1 :=
   inv_val _
 #align units.inv_mul Units.inv_mul
 #align add_units.neg_add AddUnits.neg_add
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mul_inv : (a * ↑a⁻¹ : α) = 1 :=
   val_inv _
 #align units.mul_inv Units.mul_inv
@@ -281,36 +281,36 @@ theorem mul_inv_of_eq {a : α} (h : ↑u = a) : a * ↑u⁻¹ = 1 := by rw [←
 #align units.mul_inv_of_eq Units.mul_inv_of_eq
 #align add_units.add_neg_of_eq AddUnits.add_neg_of_eq
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mul_inv_cancel_left (a : αˣ) (b : α) : (a : α) * (↑a⁻¹ * b) = b := by
   rw [← mul_assoc, mul_inv, one_mul]
 #align units.mul_inv_cancel_left Units.mul_inv_cancel_left
 #align add_units.add_neg_cancel_left AddUnits.add_neg_cancel_left
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem inv_mul_cancel_left (a : αˣ) (b : α) : (↑a⁻¹ : α) * (a * b) = b := by
   rw [← mul_assoc, inv_mul, one_mul]
 #align units.inv_mul_cancel_left Units.inv_mul_cancel_left
 #align add_units.neg_add_cancel_left AddUnits.neg_add_cancel_left
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mul_inv_cancel_right (a : α) (b : αˣ) : a * b * ↑b⁻¹ = a := by
   rw [mul_assoc, mul_inv, mul_one]
 #align units.mul_inv_cancel_right Units.mul_inv_cancel_right
 #align add_units.add_neg_cancel_right AddUnits.add_neg_cancel_right
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem inv_mul_cancel_right (a : α) (b : αˣ) : a * ↑b⁻¹ * b = a := by
   rw [mul_assoc, inv_mul, mul_one]
 #align units.inv_mul_cancel_right Units.inv_mul_cancel_right
 #align add_units.neg_add_cancel_right AddUnits.neg_add_cancel_right
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mul_right_inj (a : αˣ) {b c : α} : (a : α) * b = a * c ↔ b = c :=
   ⟨fun h => by simpa only [inv_mul_cancel_left] using congr_arg (fun x : α => ↑(a⁻¹ : αˣ) * x) h,
     congr_arg _⟩
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mul_left_inj (a : αˣ) {b c : α} : b * a = c * a ↔ b = c :=
   ⟨fun h => by simpa only [mul_inv_cancel_right] using congr_arg (fun x : α => x * ↑(a⁻¹ : αˣ)) h,
     congr_arg (· * a.val)⟩
@@ -355,11 +355,11 @@ protected theorem eq_inv_of_mul_eq_one_left {a : α} (h : ↑u * a = 1) : a = 
 protected theorem eq_inv_of_mul_eq_one_right {a : α} (h : a * u = 1) : a = ↑u⁻¹ :=
   (Units.inv_eq_of_mul_eq_one_left h).symm
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mul_inv_eq_one {a : α} : a * ↑u⁻¹ = 1 ↔ a = u :=
   ⟨inv_inv u ▸ Units.eq_inv_of_mul_eq_one_right, fun h => mul_inv_of_eq h.symm⟩
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem inv_mul_eq_one {a : α} : ↑u⁻¹ * a = 1 ↔ ↑u = a :=
   ⟨inv_inv u ▸ Units.inv_eq_of_mul_eq_one_right, inv_mul_of_eq⟩
 
@@ -373,7 +373,7 @@ theorem mul_eq_one_iff_inv_eq {a : α} : ↑u * a = 1 ↔ ↑u⁻¹ = a := by rw
 theorem inv_unique {u₁ u₂ : αˣ} (h : (↑u₁ : α) = ↑u₂) : (↑u₁⁻¹ : α) = ↑u₂⁻¹ :=
   Units.inv_eq_of_mul_eq_one_right <| by rw [h, u₂.mul_inv]
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem val_inv_eq_inv_val {M : Type _} [DivisionMonoid M] (u : Units M) : ↑u⁻¹ = (u⁻¹ : M) :=
   Eq.symm <| inv_eq_of_mul_eq_one_right u.mul_inv
 #align units.coe_inv Units.val_inv_eq_inv_val
@@ -386,7 +386,7 @@ end Units
 def Units.mkOfMulEqOne [CommMonoid α] (a b : α) (hab : a * b = 1) : αˣ :=
   ⟨a, b, hab, (mul_comm b a).trans hab⟩
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem Units.val_mkOfMulEqOne [CommMonoid α] {a b : α} (h : a * b = 1) :
     (Units.mkOfMulEqOne a b h : α) = a :=
   rfl
@@ -517,7 +517,7 @@ The actual definition says that `a` is equal to some `u : Mˣ`, where
 def IsUnit [Monoid M] (a : M) : Prop :=
   ∃ u : Mˣ, (u : M) = a
 
-@[nontriviality, to_additive]
+@[to_additive (attr := nontriviality)]
 theorem isUnit_of_subsingleton [Monoid M] [Subsingleton M] (a : M) : IsUnit a :=
   ⟨⟨a, a, Subsingleton.elim _ _, Subsingleton.elim _ _⟩, rfl⟩
 #align is_unit_of_subsingleton isUnit_of_subsingleton
@@ -534,13 +534,13 @@ instance [Monoid M] [Subsingleton M] : Unique Mˣ where
   uniq a := Units.val_eq_one.mp <| Subsingleton.elim (a : M) 1
 
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 protected theorem Units.isUnit [Monoid M] (u : Mˣ) : IsUnit (u : M) :=
   ⟨u, rfl⟩
 #align units.is_unit Units.isUnit
 #align is_add_unit_add_unit AddUnits.isAddUnit
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem isUnit_one [Monoid M] : IsUnit (1 : M) :=
   ⟨1, rfl⟩
 #align is_unit_one isUnit_one
@@ -582,7 +582,8 @@ theorem IsUnit.mul [Monoid M] {x y : M} : IsUnit x → IsUnit y → IsUnit (x *
   exact ⟨x * y, Units.val_mul _ _⟩
 
 /-- Multiplication by a `u : Mˣ` on the right doesn't affect `IsUnit`. -/
-@[simp, to_additive "Addition of a `u : add_units M` on the right doesn't affect `IsAddUnit`."]
+@[to_additive (attr := simp)
+"Addition of a `u : add_units M` on the right doesn't affect `IsAddUnit`."]
 theorem Units.isUnit_mul_units [Monoid M] (a : M) (u : Mˣ) : IsUnit (a * u) ↔ IsUnit a :=
   Iff.intro
     (fun ⟨v, hv⟩ => by
@@ -593,7 +594,8 @@ theorem Units.isUnit_mul_units [Monoid M] (a : M) (u : Mˣ) : IsUnit (a * u) ↔
 #align add_units.is_add_unit_add_add_units AddUnits.isAddUnit_add_addUnits
 
 /-- Multiplication by a `u : Mˣ` on the left doesn't affect `IsUnit`. -/
-@[simp, to_additive "Addition of a `u : add_units M` on the left doesn't affect `IsAddUnit`."]
+@[to_additive (attr := simp)
+"Addition of a `u : add_units M` on the left doesn't affect `IsAddUnit`."]
 theorem Units.isUnit_units_mul {M : Type _} [Monoid M] (u : Mˣ) (a : M) :
     IsUnit (↑u * a) ↔ IsUnit a :=
   Iff.intro
@@ -619,7 +621,7 @@ theorem isUnit_of_mul_isUnit_right [CommMonoid M] {x y : M} (hu : IsUnit (x * y)
 
 namespace IsUnit
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mul_iff [CommMonoid M] {x y : M} : IsUnit (x * y) ↔ IsUnit x ∧ IsUnit y :=
   ⟨fun h => ⟨isUnit_of_mul_isUnit_left h, isUnit_of_mul_isUnit_right h⟩,
    fun h => IsUnit.mul h.1 h.2⟩
@@ -646,23 +648,23 @@ protected noncomputable def _root_.IsAddUnit.addUnit [AddMonoid N] {a : N} (h :
 #align is_add_unit.add_unit IsAddUnit.addUnit
 attribute [to_additive] IsUnit.unit
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem unit_of_val_units {a : Mˣ} (h : IsUnit (a : M)) : h.unit = a :=
   Units.ext <| rfl
 #align is_unit.unit_of_coe_units IsUnit.unit_of_val_units
 #align is_add_unit.unit_of_coe_units IsAddUnit.addUnit_of_val_addUnits
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem unit_spec (h : IsUnit a) : ↑h.unit = a :=
   rfl
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem val_inv_mul (h : IsUnit a) : ↑h.unit⁻¹ * a = 1 :=
   Units.mul_inv _
 #align is_unit.coe_inv_mul IsUnit.val_inv_mul
 #align is_add_unit.coe_neg_add IsAddUnit.val_neg_add
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mul_val_inv (h : IsUnit a) : a * ↑h.unit⁻¹ = 1 := by
   rw [←h.unit.mul_inv]; congr
 #align is_unit.mul_coe_inv IsUnit.mul_val_inv
@@ -704,12 +706,12 @@ end Monoid
 
 variable [DivisionMonoid M] {a : M}
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 protected theorem inv_mul_cancel : IsUnit a → a⁻¹ * a = 1 := by
   rintro ⟨u, rfl⟩
   rw [← Units.val_inv_eq_inv_val, Units.inv_mul]
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 protected theorem mul_inv_cancel : IsUnit a → a * a⁻¹ = 1 := by
   rintro ⟨u, rfl⟩
   rw [← Units.val_inv_eq_inv_val, Units.mul_inv]

chore: fix casing per naming scheme (#1183)

Fix a lot of wrong casing mostly in the docstrings but also sometimes in def/theorem names. E.g. fin 2 --> Fin 2, add_monoid_hom --> AddMonoidHom

Remove \n from to_additive docstrings that were inserted by mathport.

Move files and directories with Gcd and Smul to GCD and SMul

71723d8b

Diff

@@ -724,7 +724,7 @@ section NoncomputableDefs
 
 variable {M : Type _}
 
-/-- Constructs a `Group` structure on a `monoid` consisting only of units. -/
+/-- Constructs a `Group` structure on a `Monoid` consisting only of units. -/
 noncomputable def groupOfIsUnit [hM : Monoid M] (h : ∀ a : M, IsUnit a) : Group M :=
   { hM with
     inv := fun a => ↑(h a).unit⁻¹,