algebra.invertible | Mathlib porting status

(last sync)

refactor(data/matrix/invertible): more results about invertible matrices (#19204)

Many results about invertible apply directly to matrices simply by replacing * with matrix.mul.

This also adds some missing lemmas about invertibility of products.

Diff

@@ -109,12 +109,19 @@ by { apply inv_of_eq_right_inv, rw [h, mul_inv_of_self], }
 instance [monoid α] (a : α) : subsingleton (invertible a) :=
 ⟨ λ ⟨b, hba, hab⟩ ⟨c, hca, hac⟩, by { congr, exact left_inv_eq_right_inv hba hac } ⟩
 
+/-- If `r` is invertible and `s = r` and `si = ⅟r`, then `s` is invertible with `⅟s = si`. -/
+def invertible.copy' [mul_one_class α] {r : α} (hr : invertible r) (s : α) (si : α)
+  (hs : s = r) (hsi : si = ⅟r) :
+  invertible s :=
+{ inv_of := si,
+  inv_of_mul_self := by rw [hs, hsi, inv_of_mul_self],
+  mul_inv_of_self := by rw [hs, hsi, mul_inv_of_self] }
+
 /-- If `r` is invertible and `s = r`, then `s` is invertible. -/
+@[reducible]
 def invertible.copy [mul_one_class α] {r : α} (hr : invertible r) (s : α) (hs : s = r) :
   invertible s :=
-{ inv_of := ⅟r,
-  inv_of_mul_self := by rw [hs, inv_of_mul_self],
-  mul_inv_of_self := by rw [hs, mul_inv_of_self] }
+hr.copy' _ _ hs rfl
 
 /-- An `invertible` element is a unit. -/
 @[simps]
@@ -196,6 +203,11 @@ def invertible_mul [monoid α] (a b : α) [invertible a] [invertible b] : invert
   ⅟(a * b) = ⅟b * ⅟a :=
 inv_of_eq_right_inv (by simp [←mul_assoc])
 
+/-- A copy of `invertible_mul` for dot notation. -/
+@[reducible] def invertible.mul [monoid α] {a b : α} (ha : invertible a) (hb : invertible b) :
+  invertible (a * b) :=
+invertible_mul _ _
+
 theorem commute.inv_of_right [monoid α] {a b : α} [invertible b] (h : commute a b) :
   commute a (⅟b) :=
 calc a * (⅟b) = (⅟b) * (b * a * (⅟b)) : by simp [mul_assoc]
@@ -220,6 +232,43 @@ lemma nonzero_of_invertible [mul_zero_one_class α] (a : α) [nontrivial α] [in
 @[priority 100] instance invertible.ne_zero [mul_zero_one_class α] [nontrivial α] (a : α)
   [invertible a] : ne_zero a := ⟨nonzero_of_invertible a⟩
 
+section monoid
+variables [monoid α]
+
+/-- This is the `invertible` version of `units.is_unit_units_mul` -/
+@[reducible] def invertible_of_invertible_mul (a b : α) [invertible a] [invertible (a * b)] :
+  invertible b :=
+{ inv_of := ⅟(a * b) * a,
+  inv_of_mul_self := by rw [mul_assoc, inv_of_mul_self],
+  mul_inv_of_self := by rw [←(is_unit_of_invertible a).mul_right_inj, ←mul_assoc, ←mul_assoc,
+    mul_inv_of_self, mul_one, one_mul] }
+
+/-- This is the `invertible` version of `units.is_unit_mul_units` -/
+@[reducible] def invertible_of_mul_invertible (a b : α) [invertible (a * b)] [invertible b] :
+  invertible a :=
+{ inv_of := b * ⅟(a * b),
+  inv_of_mul_self := by rw [←(is_unit_of_invertible b).mul_left_inj, mul_assoc, mul_assoc,
+    inv_of_mul_self, mul_one, one_mul],
+  mul_inv_of_self := by rw [←mul_assoc, mul_inv_of_self] }
+
+/-- `invertible_of_invertible_mul` and `invertible_mul` as an equivalence. -/
+@[simps] def invertible.mul_left {a : α} (ha : invertible a) (b : α) :
+  invertible b ≃ invertible (a * b) :=
+{ to_fun := λ hb, by exactI invertible_mul a b,
+  inv_fun := λ hab, by exactI invertible_of_invertible_mul a _,
+  left_inv := λ hb, subsingleton.elim _ _,
+  right_inv := λ hab, subsingleton.elim _ _, }
+
+/-- `invertible_of_mul_invertible` and `invertible_mul` as an equivalence. -/
+@[simps] def invertible.mul_right (a : α) {b : α} (ha : invertible b) :
+  invertible a ≃ invertible (a * b) :=
+{ to_fun := λ hb, by exactI invertible_mul a b,
+  inv_fun := λ hab, by exactI invertible_of_mul_invertible _ b,
+  left_inv := λ hb, subsingleton.elim _ _,
+  right_inv := λ hab, subsingleton.elim _ _, }
+
+end monoid
+
 section monoid_with_zero
 variable [monoid_with_zero α]

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -266,7 +266,7 @@ theorem invOf_neg [Monoid α] [HasDistribNeg α] (a : α) [Invertible a] [Invert
 @[simp]
 theorem one_sub_invOf_two [Ring α] [Invertible (2 : α)] : 1 - (⅟ 2 : α) = ⅟ 2 :=
   (isUnit_of_invertible (2 : α)).mul_right_inj.1 <| by
-    rw [mul_sub, mul_invOf_self, mul_one, bit0, add_sub_cancel]
+    rw [mul_sub, mul_invOf_self, mul_one, bit0, add_sub_cancel_right]
 #align one_sub_inv_of_two one_sub_invOf_two
 -/
 
@@ -472,14 +472,14 @@ theorem mul_inv_cancel_of_invertible (a : α) [Invertible a] : a * a⁻¹ = 1 :=
 #print div_mul_cancel_of_invertible /-
 @[simp]
 theorem div_mul_cancel_of_invertible (a b : α) [Invertible b] : a / b * b = a :=
-  div_mul_cancel a (nonzero_of_invertible b)
+  div_mul_cancel₀ a (nonzero_of_invertible b)
 #align div_mul_cancel_of_invertible div_mul_cancel_of_invertible
 -/
 
 #print mul_div_cancel_of_invertible /-
 @[simp]
 theorem mul_div_cancel_of_invertible (a b : α) [Invertible b] : a * b / b = a :=
-  mul_div_cancel a (nonzero_of_invertible b)
+  mul_div_cancel_right₀ a (nonzero_of_invertible b)
 #align mul_div_cancel_of_invertible mul_div_cancel_of_invertible
 -/

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) 2020 Anne Baanen. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anne Baanen
 -/
-import Mathbin.Algebra.Group.Units
-import Mathbin.Algebra.GroupWithZero.Units.Lemmas
-import Mathbin.Algebra.Ring.Defs
+import Algebra.Group.Units
+import Algebra.GroupWithZero.Units.Lemmas
+import Algebra.Ring.Defs
 
 #align_import algebra.invertible from "leanprover-community/mathlib"@"722b3b152ddd5e0cf21c0a29787c76596cb6b422"

bump to nightly-2023-08-17-09

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

60285dcc

Diff

@@ -70,8 +70,8 @@ variable {α : Type u}
 /-- `invertible a` gives a two-sided multiplicative inverse of `a`. -/
 class Invertible [Mul α] [One α] (a : α) : Type u where
   invOf : α
-  invOf_mul_self : inv_of * a = 1
-  mul_invOf_self : a * inv_of = 1
+  invOf_hMul_self : inv_of * a = 1
+  hMul_invOf_self : a * inv_of = 1
 #align invertible Invertible
 -/
 
@@ -82,14 +82,14 @@ notation:1034
 #print invOf_mul_self /-
 @[simp]
 theorem invOf_mul_self [Mul α] [One α] (a : α) [Invertible a] : ⅟ a * a = 1 :=
-  Invertible.invOf_mul_self
+  Invertible.invOf_hMul_self
 #align inv_of_mul_self invOf_mul_self
 -/
 
 #print mul_invOf_self /-
 @[simp]
 theorem mul_invOf_self [Mul α] [One α] (a : α) [Invertible a] : a * ⅟ a = 1 :=
-  Invertible.mul_invOf_self
+  Invertible.hMul_invOf_self
 #align mul_inv_of_self mul_invOf_self
 -/
 
@@ -147,8 +147,8 @@ instance [Monoid α] (a : α) : Subsingleton (Invertible a) :=
 def Invertible.copy' [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (si : α) (hs : s = r)
     (hsi : si = ⅟ r) : Invertible s where
   invOf := si
-  invOf_mul_self := by rw [hs, hsi, invOf_mul_self]
-  mul_invOf_self := by rw [hs, hsi, mul_invOf_self]
+  invOf_hMul_self := by rw [hs, hsi, invOf_mul_self]
+  hMul_invOf_self := by rw [hs, hsi, mul_invOf_self]
 #align invertible.copy' Invertible.copy'
 -/
 
@@ -184,8 +184,8 @@ theorem isUnit_of_invertible [Monoid α] (a : α) [Invertible a] : IsUnit a :=
 def Units.invertible [Monoid α] (u : αˣ) : Invertible (u : α)
     where
   invOf := ↑u⁻¹
-  invOf_mul_self := u.inv_mul
-  mul_invOf_self := u.mul_inv
+  invOf_hMul_self := u.inv_mul
+  hMul_invOf_self := u.mul_inv
 #align units.invertible Units.invertible
 -/
 
@@ -377,8 +377,8 @@ variable [Monoid α]
 def invertibleOfInvertibleMul (a b : α) [Invertible a] [Invertible (a * b)] : Invertible b
     where
   invOf := ⅟ (a * b) * a
-  invOf_mul_self := by rw [mul_assoc, invOf_mul_self]
-  mul_invOf_self := by
+  invOf_hMul_self := by rw [mul_assoc, invOf_mul_self]
+  hMul_invOf_self := by
     rw [← (isUnit_of_invertible a).mul_right_inj, ← mul_assoc, ← mul_assoc, mul_invOf_self, mul_one,
       one_mul]
 #align invertible_of_invertible_mul invertibleOfInvertibleMul
@@ -390,10 +390,10 @@ def invertibleOfInvertibleMul (a b : α) [Invertible a] [Invertible (a * b)] : I
 def invertibleOfMulInvertible (a b : α) [Invertible (a * b)] [Invertible b] : Invertible a
     where
   invOf := b * ⅟ (a * b)
-  invOf_mul_self := by
+  invOf_hMul_self := by
     rw [← (isUnit_of_invertible b).mul_left_inj, mul_assoc, mul_assoc, invOf_mul_self, mul_one,
       one_mul]
-  mul_invOf_self := by rw [← mul_assoc, mul_invOf_self]
+  hMul_invOf_self := by rw [← mul_assoc, mul_invOf_self]
 #align invertible_of_mul_invertible invertibleOfMulInvertible
 -/
 
@@ -520,8 +520,8 @@ def Invertible.map {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [MulOn
     [MonoidHomClass F R S] (f : F) (r : R) [Invertible r] : Invertible (f r)
     where
   invOf := f (⅟ r)
-  invOf_mul_self := by rw [← map_mul, invOf_mul_self, map_one]
-  mul_invOf_self := by rw [← map_mul, mul_invOf_self, map_one]
+  invOf_hMul_self := by rw [← map_mul, invOf_mul_self, map_one]
+  hMul_invOf_self := by rw [← map_mul, mul_invOf_self, map_one]
 #align invertible.map Invertible.map
 -/

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) 2020 Anne Baanen. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anne Baanen
-
-! This file was ported from Lean 3 source module algebra.invertible
-! leanprover-community/mathlib commit 722b3b152ddd5e0cf21c0a29787c76596cb6b422
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Group.Units
 import Mathbin.Algebra.GroupWithZero.Units.Lemmas
 import Mathbin.Algebra.Ring.Defs
 
+#align_import algebra.invertible from "leanprover-community/mathlib"@"722b3b152ddd5e0cf21c0a29787c76596cb6b422"
+
 /-!
 # Invertible elements

bump to nightly-2023-06-22-15

mathlib commit https://github.com/leanprover-community/mathlib/commit/6285167a053ad0990fc88e56c48ccd9fae6550eb

6726617a

Diff

@@ -145,6 +145,7 @@ theorem invertible_unique {α : Type u} [Monoid α] (a b : α) [Invertible a] [I
 instance [Monoid α] (a : α) : Subsingleton (Invertible a) :=
   ⟨fun ⟨b, hba, hab⟩ ⟨c, hca, hac⟩ => by congr; exact left_inv_eq_right_inv hba hac⟩
 
+#print Invertible.copy' /-
 /-- If `r` is invertible and `s = r` and `si = ⅟r`, then `s` is invertible with `⅟s = si`. -/
 def Invertible.copy' [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (si : α) (hs : s = r)
     (hsi : si = ⅟ r) : Invertible s where
@@ -152,6 +153,7 @@ def Invertible.copy' [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (si
   invOf_mul_self := by rw [hs, hsi, invOf_mul_self]
   mul_invOf_self := by rw [hs, hsi, mul_invOf_self]
 #align invertible.copy' Invertible.copy'
+-/
 
 #print Invertible.copy /-
 /-- If `r` is invertible and `s = r`, then `s` is invertible. -/
@@ -314,12 +316,14 @@ theorem invOf_mul [Monoid α] (a b : α) [Invertible a] [Invertible b] [Invertib
 #align inv_of_mul invOf_mul
 -/
 
+#print Invertible.mul /-
 /-- A copy of `invertible_mul` for dot notation. -/
 @[reducible]
 def Invertible.mul [Monoid α] {a b : α} (ha : Invertible a) (hb : Invertible b) :
     Invertible (a * b) :=
   invertibleMul _ _
 #align invertible.mul Invertible.mul
+-/
 
 #print Commute.invOf_right /-
 theorem Commute.invOf_right [Monoid α] {a b : α} [Invertible b] (h : Commute a b) :
@@ -370,6 +374,7 @@ section Monoid
 
 variable [Monoid α]
 
+#print invertibleOfInvertibleMul /-
 /-- This is the `invertible` version of `units.is_unit_units_mul` -/
 @[reducible]
 def invertibleOfInvertibleMul (a b : α) [Invertible a] [Invertible (a * b)] : Invertible b
@@ -380,7 +385,9 @@ def invertibleOfInvertibleMul (a b : α) [Invertible a] [Invertible (a * b)] : I
     rw [← (isUnit_of_invertible a).mul_right_inj, ← mul_assoc, ← mul_assoc, mul_invOf_self, mul_one,
       one_mul]
 #align invertible_of_invertible_mul invertibleOfInvertibleMul
+-/
 
+#print invertibleOfMulInvertible /-
 /-- This is the `invertible` version of `units.is_unit_mul_units` -/
 @[reducible]
 def invertibleOfMulInvertible (a b : α) [Invertible (a * b)] [Invertible b] : Invertible a
@@ -391,7 +398,9 @@ def invertibleOfMulInvertible (a b : α) [Invertible (a * b)] [Invertible b] : I
       one_mul]
   mul_invOf_self := by rw [← mul_assoc, mul_invOf_self]
 #align invertible_of_mul_invertible invertibleOfMulInvertible
+-/
 
+#print Invertible.mulLeft /-
 /-- `invertible_of_invertible_mul` and `invertible_mul` as an equivalence. -/
 @[simps]
 def Invertible.mulLeft {a : α} (ha : Invertible a) (b : α) : Invertible b ≃ Invertible (a * b)
@@ -401,7 +410,9 @@ def Invertible.mulLeft {a : α} (ha : Invertible a) (b : α) : Invertible b ≃
   left_inv hb := Subsingleton.elim _ _
   right_inv hab := Subsingleton.elim _ _
 #align invertible.mul_left Invertible.mulLeft
+-/
 
+#print Invertible.mulRight /-
 /-- `invertible_of_mul_invertible` and `invertible_mul` as an equivalence. -/
 @[simps]
 def Invertible.mulRight (a : α) {b : α} (ha : Invertible b) : Invertible a ≃ Invertible (a * b)
@@ -411,6 +422,7 @@ def Invertible.mulRight (a : α) {b : α} (ha : Invertible b) : Invertible a ≃
   left_inv hb := Subsingleton.elim _ _
   right_inv hab := Subsingleton.elim _ _
 #align invertible.mul_right Invertible.mulRight
+-/
 
 end Monoid

bump to nightly-2023-06-22-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/6285167a053ad0990fc88e56c48ccd9fae6550eb

2424c6fa

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anne Baanen
 
 ! This file was ported from Lean 3 source module algebra.invertible
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
+! leanprover-community/mathlib commit 722b3b152ddd5e0cf21c0a29787c76596cb6b422
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -145,13 +145,20 @@ theorem invertible_unique {α : Type u} [Monoid α] (a b : α) [Invertible a] [I
 instance [Monoid α] (a : α) : Subsingleton (Invertible a) :=
   ⟨fun ⟨b, hba, hab⟩ ⟨c, hca, hac⟩ => by congr; exact left_inv_eq_right_inv hba hac⟩
 
+/-- If `r` is invertible and `s = r` and `si = ⅟r`, then `s` is invertible with `⅟s = si`. -/
+def Invertible.copy' [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (si : α) (hs : s = r)
+    (hsi : si = ⅟ r) : Invertible s where
+  invOf := si
+  invOf_mul_self := by rw [hs, hsi, invOf_mul_self]
+  mul_invOf_self := by rw [hs, hsi, mul_invOf_self]
+#align invertible.copy' Invertible.copy'
+
 #print Invertible.copy /-
 /-- If `r` is invertible and `s = r`, then `s` is invertible. -/
-def Invertible.copy [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (hs : s = r) : Invertible s
-    where
-  invOf := ⅟ r
-  invOf_mul_self := by rw [hs, invOf_mul_self]
-  mul_invOf_self := by rw [hs, mul_invOf_self]
+@[reducible]
+def Invertible.copy [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (hs : s = r) :
+    Invertible s :=
+  hr.copy' _ _ hs rfl
 #align invertible.copy Invertible.copy
 -/
 
@@ -307,6 +314,13 @@ theorem invOf_mul [Monoid α] (a b : α) [Invertible a] [Invertible b] [Invertib
 #align inv_of_mul invOf_mul
 -/
 
+/-- A copy of `invertible_mul` for dot notation. -/
+@[reducible]
+def Invertible.mul [Monoid α] {a b : α} (ha : Invertible a) (hb : Invertible b) :
+    Invertible (a * b) :=
+  invertibleMul _ _
+#align invertible.mul Invertible.mul
+
 #print Commute.invOf_right /-
 theorem Commute.invOf_right [Monoid α] {a b : α} [Invertible b] (h : Commute a b) :
     Commute a (⅟ b) :=
@@ -352,6 +366,54 @@ instance (priority := 100) Invertible.ne_zero [MulZeroOneClass α] [Nontrivial 
 #align invertible.ne_zero Invertible.ne_zero
 -/
 
+section Monoid
+
+variable [Monoid α]
+
+/-- This is the `invertible` version of `units.is_unit_units_mul` -/
+@[reducible]
+def invertibleOfInvertibleMul (a b : α) [Invertible a] [Invertible (a * b)] : Invertible b
+    where
+  invOf := ⅟ (a * b) * a
+  invOf_mul_self := by rw [mul_assoc, invOf_mul_self]
+  mul_invOf_self := by
+    rw [← (isUnit_of_invertible a).mul_right_inj, ← mul_assoc, ← mul_assoc, mul_invOf_self, mul_one,
+      one_mul]
+#align invertible_of_invertible_mul invertibleOfInvertibleMul
+
+/-- This is the `invertible` version of `units.is_unit_mul_units` -/
+@[reducible]
+def invertibleOfMulInvertible (a b : α) [Invertible (a * b)] [Invertible b] : Invertible a
+    where
+  invOf := b * ⅟ (a * b)
+  invOf_mul_self := by
+    rw [← (isUnit_of_invertible b).mul_left_inj, mul_assoc, mul_assoc, invOf_mul_self, mul_one,
+      one_mul]
+  mul_invOf_self := by rw [← mul_assoc, mul_invOf_self]
+#align invertible_of_mul_invertible invertibleOfMulInvertible
+
+/-- `invertible_of_invertible_mul` and `invertible_mul` as an equivalence. -/
+@[simps]
+def Invertible.mulLeft {a : α} (ha : Invertible a) (b : α) : Invertible b ≃ Invertible (a * b)
+    where
+  toFun hb := invertibleMul a b
+  invFun hab := invertibleOfInvertibleMul a _
+  left_inv hb := Subsingleton.elim _ _
+  right_inv hab := Subsingleton.elim _ _
+#align invertible.mul_left Invertible.mulLeft
+
+/-- `invertible_of_mul_invertible` and `invertible_mul` as an equivalence. -/
+@[simps]
+def Invertible.mulRight (a : α) {b : α} (ha : Invertible b) : Invertible a ≃ Invertible (a * b)
+    where
+  toFun hb := invertibleMul a b
+  invFun hab := invertibleOfMulInvertible _ b
+  left_inv hb := Subsingleton.elim _ _
+  right_inv hab := Subsingleton.elim _ _
+#align invertible.mul_right Invertible.mulRight
+
+end Monoid
+
 section MonoidWithZero
 
 variable [MonoidWithZero α]

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -78,7 +78,6 @@ class Invertible [Mul α] [One α] (a : α) : Type u where
 #align invertible Invertible
 -/
 
--- mathport name: «expr⅟»
 notation:1034
   "⅟" =>-- This notation has the same precedence as `has_inv.inv`.
   Invertible.invOf
@@ -97,41 +96,56 @@ theorem mul_invOf_self [Mul α] [One α] (a : α) [Invertible a] : a * ⅟ a = 1
 #align mul_inv_of_self mul_invOf_self
 -/
 
+#print invOf_mul_self_assoc /-
 @[simp]
 theorem invOf_mul_self_assoc [Monoid α] (a b : α) [Invertible a] : ⅟ a * (a * b) = b := by
   rw [← mul_assoc, invOf_mul_self, one_mul]
 #align inv_of_mul_self_assoc invOf_mul_self_assoc
+-/
 
+#print mul_invOf_self_assoc /-
 @[simp]
 theorem mul_invOf_self_assoc [Monoid α] (a b : α) [Invertible a] : a * (⅟ a * b) = b := by
   rw [← mul_assoc, mul_invOf_self, one_mul]
 #align mul_inv_of_self_assoc mul_invOf_self_assoc
+-/
 
+#print mul_invOf_mul_self_cancel /-
 @[simp]
 theorem mul_invOf_mul_self_cancel [Monoid α] (a b : α) [Invertible b] : a * ⅟ b * b = a := by
   simp [mul_assoc]
 #align mul_inv_of_mul_self_cancel mul_invOf_mul_self_cancel
+-/
 
+#print mul_mul_invOf_self_cancel /-
 @[simp]
 theorem mul_mul_invOf_self_cancel [Monoid α] (a b : α) [Invertible b] : a * b * ⅟ b = a := by
   simp [mul_assoc]
 #align mul_mul_inv_of_self_cancel mul_mul_invOf_self_cancel
+-/
 
+#print invOf_eq_right_inv /-
 theorem invOf_eq_right_inv [Monoid α] {a b : α} [Invertible a] (hac : a * b = 1) : ⅟ a = b :=
   left_inv_eq_right_inv (invOf_mul_self _) hac
 #align inv_of_eq_right_inv invOf_eq_right_inv
+-/
 
+#print invOf_eq_left_inv /-
 theorem invOf_eq_left_inv [Monoid α] {a b : α} [Invertible a] (hac : b * a = 1) : ⅟ a = b :=
   (left_inv_eq_right_inv hac (mul_invOf_self _)).symm
 #align inv_of_eq_left_inv invOf_eq_left_inv
+-/
 
+#print invertible_unique /-
 theorem invertible_unique {α : Type u} [Monoid α] (a b : α) [Invertible a] [Invertible b]
     (h : a = b) : ⅟ a = ⅟ b := by apply invOf_eq_right_inv; rw [h, mul_invOf_self]
 #align invertible_unique invertible_unique
+-/
 
 instance [Monoid α] (a : α) : Subsingleton (Invertible a) :=
   ⟨fun ⟨b, hba, hab⟩ ⟨c, hca, hac⟩ => by congr; exact left_inv_eq_right_inv hba hac⟩
 
+#print Invertible.copy /-
 /-- If `r` is invertible and `s = r`, then `s` is invertible. -/
 def Invertible.copy [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (hs : s = r) : Invertible s
     where
@@ -139,7 +153,9 @@ def Invertible.copy [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (hs :
   invOf_mul_self := by rw [hs, invOf_mul_self]
   mul_invOf_self := by rw [hs, mul_invOf_self]
 #align invertible.copy Invertible.copy
+-/
 
+#print unitOfInvertible /-
 /-- An `invertible` element is a unit. -/
 @[simps]
 def unitOfInvertible [Monoid α] (a : α) [Invertible a] : αˣ
@@ -149,11 +165,15 @@ def unitOfInvertible [Monoid α] (a : α) [Invertible a] : αˣ
   val_inv := by simp
   inv_val := by simp
 #align unit_of_invertible unitOfInvertible
+-/
 
+#print isUnit_of_invertible /-
 theorem isUnit_of_invertible [Monoid α] (a : α) [Invertible a] : IsUnit a :=
   ⟨unitOfInvertible a, rfl⟩
 #align is_unit_of_invertible isUnit_of_invertible
+-/
 
+#print Units.invertible /-
 /-- Units are invertible in their associated monoid. -/
 def Units.invertible [Monoid α] (u : αˣ) : Invertible (u : α)
     where
@@ -161,70 +181,95 @@ def Units.invertible [Monoid α] (u : αˣ) : Invertible (u : α)
   invOf_mul_self := u.inv_mul
   mul_invOf_self := u.mul_inv
 #align units.invertible Units.invertible
+-/
 
+#print invOf_units /-
 @[simp]
 theorem invOf_units [Monoid α] (u : αˣ) [Invertible (u : α)] : ⅟ (u : α) = ↑u⁻¹ :=
   invOf_eq_right_inv u.mul_inv
 #align inv_of_units invOf_units
+-/
 
+#print IsUnit.nonempty_invertible /-
 theorem IsUnit.nonempty_invertible [Monoid α] {a : α} (h : IsUnit a) : Nonempty (Invertible a) :=
   let ⟨x, hx⟩ := h
   ⟨x.Invertible.copy _ hx.symm⟩
 #align is_unit.nonempty_invertible IsUnit.nonempty_invertible
+-/
 
+#print IsUnit.invertible /-
 /-- Convert `is_unit` to `invertible` using `classical.choice`.
 
 Prefer `casesI h.nonempty_invertible` over `letI := h.invertible` if you want to avoid choice. -/
 noncomputable def IsUnit.invertible [Monoid α] {a : α} (h : IsUnit a) : Invertible a :=
   Classical.choice h.nonempty_invertible
 #align is_unit.invertible IsUnit.invertible
+-/
 
+#print nonempty_invertible_iff_isUnit /-
 @[simp]
 theorem nonempty_invertible_iff_isUnit [Monoid α] (a : α) : Nonempty (Invertible a) ↔ IsUnit a :=
   ⟨Nonempty.ndrec <| @isUnit_of_invertible _ _ _, IsUnit.nonempty_invertible⟩
 #align nonempty_invertible_iff_is_unit nonempty_invertible_iff_isUnit
+-/
 
+#print invertibleOfGroup /-
 /-- Each element of a group is invertible. -/
 def invertibleOfGroup [Group α] (a : α) : Invertible a :=
   ⟨a⁻¹, inv_mul_self a, mul_inv_self a⟩
 #align invertible_of_group invertibleOfGroup
+-/
 
+#print invOf_eq_group_inv /-
 @[simp]
 theorem invOf_eq_group_inv [Group α] (a : α) [Invertible a] : ⅟ a = a⁻¹ :=
   invOf_eq_right_inv (mul_inv_self a)
 #align inv_of_eq_group_inv invOf_eq_group_inv
+-/
 
+#print invertibleOne /-
 /-- `1` is the inverse of itself -/
 def invertibleOne [Monoid α] : Invertible (1 : α) :=
   ⟨1, mul_one _, one_mul _⟩
 #align invertible_one invertibleOne
+-/
 
+#print invOf_one /-
 @[simp]
 theorem invOf_one [Monoid α] [Invertible (1 : α)] : ⅟ (1 : α) = 1 :=
   invOf_eq_right_inv (mul_one _)
 #align inv_of_one invOf_one
+-/
 
+#print invertibleNeg /-
 /-- `-⅟a` is the inverse of `-a` -/
 def invertibleNeg [Mul α] [One α] [HasDistribNeg α] (a : α) [Invertible a] : Invertible (-a) :=
   ⟨-⅟ a, by simp, by simp⟩
 #align invertible_neg invertibleNeg
+-/
 
+#print invOf_neg /-
 @[simp]
 theorem invOf_neg [Monoid α] [HasDistribNeg α] (a : α) [Invertible a] [Invertible (-a)] :
     ⅟ (-a) = -⅟ a :=
   invOf_eq_right_inv (by simp)
 #align inv_of_neg invOf_neg
+-/
 
+#print one_sub_invOf_two /-
 @[simp]
 theorem one_sub_invOf_two [Ring α] [Invertible (2 : α)] : 1 - (⅟ 2 : α) = ⅟ 2 :=
   (isUnit_of_invertible (2 : α)).mul_right_inj.1 <| by
     rw [mul_sub, mul_invOf_self, mul_one, bit0, add_sub_cancel]
 #align one_sub_inv_of_two one_sub_invOf_two
+-/
 
+#print invOf_two_add_invOf_two /-
 @[simp]
 theorem invOf_two_add_invOf_two [NonAssocSemiring α] [Invertible (2 : α)] :
     (⅟ 2 : α) + (⅟ 2 : α) = 1 := by rw [← two_mul, mul_invOf_self]
 #align inv_of_two_add_inv_of_two invOf_two_add_invOf_two
+-/
 
 #print invertibleInvOf /-
 /-- `a` is the inverse of `⅟a`. -/
@@ -233,27 +278,36 @@ instance invertibleInvOf [One α] [Mul α] {a : α} [Invertible a] : Invertible
 #align invertible_inv_of invertibleInvOf
 -/
 
+#print invOf_invOf /-
 @[simp]
 theorem invOf_invOf [Monoid α] (a : α) [Invertible a] [Invertible (⅟ a)] : ⅟ (⅟ a) = a :=
   invOf_eq_right_inv (invOf_mul_self _)
 #align inv_of_inv_of invOf_invOf
+-/
 
+#print invOf_inj /-
 @[simp]
 theorem invOf_inj [Monoid α] {a b : α} [Invertible a] [Invertible b] : ⅟ a = ⅟ b ↔ a = b :=
   ⟨invertible_unique _ _, invertible_unique _ _⟩
 #align inv_of_inj invOf_inj
+-/
 
+#print invertibleMul /-
 /-- `⅟b * ⅟a` is the inverse of `a * b` -/
 def invertibleMul [Monoid α] (a b : α) [Invertible a] [Invertible b] : Invertible (a * b) :=
   ⟨⅟ b * ⅟ a, by simp [← mul_assoc], by simp [← mul_assoc]⟩
 #align invertible_mul invertibleMul
+-/
 
+#print invOf_mul /-
 @[simp]
 theorem invOf_mul [Monoid α] (a b : α) [Invertible a] [Invertible b] [Invertible (a * b)] :
     ⅟ (a * b) = ⅟ b * ⅟ a :=
   invOf_eq_right_inv (by simp [← mul_assoc])
 #align inv_of_mul invOf_mul
+-/
 
+#print Commute.invOf_right /-
 theorem Commute.invOf_right [Monoid α] {a b : α} [Invertible b] (h : Commute a b) :
     Commute a (⅟ b) :=
   calc
@@ -261,7 +315,9 @@ theorem Commute.invOf_right [Monoid α] {a b : α} [Invertible b] (h : Commute a
     _ = ⅟ b * (a * b * ⅟ b) := by rw [h.eq]
     _ = ⅟ b * a := by simp [mul_assoc]
 #align commute.inv_of_right Commute.invOf_right
+-/
 
+#print Commute.invOf_left /-
 theorem Commute.invOf_left [Monoid α] {a b : α} [Invertible b] (h : Commute b a) :
     Commute (⅟ b) a :=
   calc
@@ -269,6 +325,7 @@ theorem Commute.invOf_left [Monoid α] {a b : α} [Invertible b] (h : Commute b
     _ = ⅟ b * (b * a * ⅟ b) := by rw [h.eq]
     _ = a * ⅟ b := by simp [mul_assoc]
 #align commute.inv_of_left Commute.invOf_left
+-/
 
 #print commute_invOf /-
 theorem commute_invOf {M : Type _} [One M] [Mul M] (m : M) [Invertible m] : Commute m (⅟ m) :=
@@ -278,6 +335,7 @@ theorem commute_invOf {M : Type _} [One M] [Mul M] (m : M) [Invertible m] : Comm
 #align commute_inv_of commute_invOf
 -/
 
+#print nonzero_of_invertible /-
 theorem nonzero_of_invertible [MulZeroOneClass α] (a : α) [Nontrivial α] [Invertible a] : a ≠ 0 :=
   fun ha =>
   zero_ne_one <|
@@ -285,21 +343,26 @@ theorem nonzero_of_invertible [MulZeroOneClass α] (a : α) [Nontrivial α] [Inv
       0 = ⅟ a * a := by simp [ha]
       _ = 1 := invOf_mul_self a
 #align nonzero_of_invertible nonzero_of_invertible
+-/
 
+#print Invertible.ne_zero /-
 instance (priority := 100) Invertible.ne_zero [MulZeroOneClass α] [Nontrivial α] (a : α)
     [Invertible a] : NeZero a :=
   ⟨nonzero_of_invertible a⟩
 #align invertible.ne_zero Invertible.ne_zero
+-/
 
 section MonoidWithZero
 
 variable [MonoidWithZero α]
 
+#print Ring.inverse_invertible /-
 /-- A variant of `ring.inverse_unit`. -/
 @[simp]
 theorem Ring.inverse_invertible (x : α) [Invertible x] : Ring.inverse x = ⅟ x :=
   Ring.inverse_unit (unitOfInvertible _)
 #align ring.inverse_invertible Ring.inverse_invertible
+-/
 
 end MonoidWithZero
 
@@ -307,59 +370,80 @@ section GroupWithZero
 
 variable [GroupWithZero α]
 
+#print invertibleOfNonzero /-
 /-- `a⁻¹` is an inverse of `a` if `a ≠ 0` -/
 def invertibleOfNonzero {a : α} (h : a ≠ 0) : Invertible a :=
   ⟨a⁻¹, inv_mul_cancel h, mul_inv_cancel h⟩
 #align invertible_of_nonzero invertibleOfNonzero
+-/
 
+#print invOf_eq_inv /-
 @[simp]
 theorem invOf_eq_inv (a : α) [Invertible a] : ⅟ a = a⁻¹ :=
   invOf_eq_right_inv (mul_inv_cancel (nonzero_of_invertible a))
 #align inv_of_eq_inv invOf_eq_inv
+-/
 
+#print inv_mul_cancel_of_invertible /-
 @[simp]
 theorem inv_mul_cancel_of_invertible (a : α) [Invertible a] : a⁻¹ * a = 1 :=
   inv_mul_cancel (nonzero_of_invertible a)
 #align inv_mul_cancel_of_invertible inv_mul_cancel_of_invertible
+-/
 
+#print mul_inv_cancel_of_invertible /-
 @[simp]
 theorem mul_inv_cancel_of_invertible (a : α) [Invertible a] : a * a⁻¹ = 1 :=
   mul_inv_cancel (nonzero_of_invertible a)
 #align mul_inv_cancel_of_invertible mul_inv_cancel_of_invertible
+-/
 
+#print div_mul_cancel_of_invertible /-
 @[simp]
 theorem div_mul_cancel_of_invertible (a b : α) [Invertible b] : a / b * b = a :=
   div_mul_cancel a (nonzero_of_invertible b)
 #align div_mul_cancel_of_invertible div_mul_cancel_of_invertible
+-/
 
+#print mul_div_cancel_of_invertible /-
 @[simp]
 theorem mul_div_cancel_of_invertible (a b : α) [Invertible b] : a * b / b = a :=
   mul_div_cancel a (nonzero_of_invertible b)
 #align mul_div_cancel_of_invertible mul_div_cancel_of_invertible
+-/
 
+#print div_self_of_invertible /-
 @[simp]
 theorem div_self_of_invertible (a : α) [Invertible a] : a / a = 1 :=
   div_self (nonzero_of_invertible a)
 #align div_self_of_invertible div_self_of_invertible
+-/
 
+#print invertibleDiv /-
 /-- `b / a` is the inverse of `a / b` -/
 def invertibleDiv (a b : α) [Invertible a] [Invertible b] : Invertible (a / b) :=
   ⟨b / a, by simp [← mul_div_assoc], by simp [← mul_div_assoc]⟩
 #align invertible_div invertibleDiv
+-/
 
+#print invOf_div /-
 @[simp]
 theorem invOf_div (a b : α) [Invertible a] [Invertible b] [Invertible (a / b)] :
     ⅟ (a / b) = b / a :=
   invOf_eq_right_inv (by simp [← mul_div_assoc])
 #align inv_of_div invOf_div
+-/
 
+#print invertibleInv /-
 /-- `a` is the inverse of `a⁻¹` -/
 def invertibleInv {a : α} [Invertible a] : Invertible a⁻¹ :=
   ⟨a, by simp, by simp⟩
 #align invertible_inv invertibleInv
+-/
 
 end GroupWithZero
 
+#print Invertible.map /-
 /-- Monoid homs preserve invertibility. -/
 def Invertible.map {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [MulOneClass S]
     [MonoidHomClass F R S] (f : F) (r : R) [Invertible r] : Invertible (f r)
@@ -368,14 +452,18 @@ def Invertible.map {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [MulOn
   invOf_mul_self := by rw [← map_mul, invOf_mul_self, map_one]
   mul_invOf_self := by rw [← map_mul, mul_invOf_self, map_one]
 #align invertible.map Invertible.map
+-/
 
+#print map_invOf /-
 /-- Note that the `invertible (f r)` argument can be satisfied by using `letI := invertible.map f r`
 before applying this lemma. -/
 theorem map_invOf {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [Monoid S]
     [MonoidHomClass F R S] (f : F) (r : R) [Invertible r] [Invertible (f r)] : f (⅟ r) = ⅟ (f r) :=
   by letI := Invertible.map f r; convert rfl
 #align map_inv_of map_invOf
+-/
 
+#print Invertible.ofLeftInverse /-
 /-- If a function `f : R → S` has a left-inverse that is a monoid hom,
   then `r : R` is invertible if `f r` is.
 
@@ -386,7 +474,9 @@ def Invertible.ofLeftInverse {R : Type _} {S : Type _} {G : Type _} [MulOneClass
     [Invertible (f r)] : Invertible r :=
   (Invertible.map g (f r)).copy _ (h r).symm
 #align invertible.of_left_inverse Invertible.ofLeftInverse
+-/
 
+#print invertibleEquivOfLeftInverse /-
 /-- Invertibility on either side of a monoid hom with a left-inverse is equivalent. -/
 @[simps]
 def invertibleEquivOfLeftInverse {R : Type _} {S : Type _} {F G : Type _} [Monoid R] [Monoid S]
@@ -398,4 +488,5 @@ def invertibleEquivOfLeftInverse {R : Type _} {S : Type _} {F G : Type _} [Monoi
   left_inv x := Subsingleton.elim _ _
   right_inv x := Subsingleton.elim _ _
 #align invertible_equiv_of_left_inverse invertibleEquivOfLeftInverse
+-/

bump to nightly-2023-06-09-07

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

16afdc39

Diff

@@ -260,7 +260,6 @@ theorem Commute.invOf_right [Monoid α] {a b : α} [Invertible b] (h : Commute a
     a * ⅟ b = ⅟ b * (b * a * ⅟ b) := by simp [mul_assoc]
     _ = ⅟ b * (a * b * ⅟ b) := by rw [h.eq]
     _ = ⅟ b * a := by simp [mul_assoc]
-    
 #align commute.inv_of_right Commute.invOf_right
 
 theorem Commute.invOf_left [Monoid α] {a b : α} [Invertible b] (h : Commute b a) :
@@ -269,7 +268,6 @@ theorem Commute.invOf_left [Monoid α] {a b : α} [Invertible b] (h : Commute b
     ⅟ b * a = ⅟ b * (a * b * ⅟ b) := by simp [mul_assoc]
     _ = ⅟ b * (b * a * ⅟ b) := by rw [h.eq]
     _ = a * ⅟ b := by simp [mul_assoc]
-    
 #align commute.inv_of_left Commute.invOf_left
 
 #print commute_invOf /-
@@ -277,7 +275,6 @@ theorem commute_invOf {M : Type _} [One M] [Mul M] (m : M) [Invertible m] : Comm
   calc
     m * ⅟ m = 1 := mul_invOf_self m
     _ = ⅟ m * m := (invOf_mul_self m).symm
-    
 #align commute_inv_of commute_invOf
 -/
 
@@ -287,7 +284,6 @@ theorem nonzero_of_invertible [MulZeroOneClass α] (a : α) [Nontrivial α] [Inv
     calc
       0 = ⅟ a * a := by simp [ha]
       _ = 1 := invOf_mul_self a
-      
 #align nonzero_of_invertible nonzero_of_invertible
 
 instance (priority := 100) Invertible.ne_zero [MulZeroOneClass α] [Nontrivial α] (a : α)

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -130,7 +130,7 @@ theorem invertible_unique {α : Type u} [Monoid α] (a b : α) [Invertible a] [I
 #align invertible_unique invertible_unique
 
 instance [Monoid α] (a : α) : Subsingleton (Invertible a) :=
-  ⟨fun ⟨b, hba, hab⟩ ⟨c, hca, hac⟩ => by congr ; exact left_inv_eq_right_inv hba hac⟩
+  ⟨fun ⟨b, hba, hab⟩ ⟨c, hca, hac⟩ => by congr; exact left_inv_eq_right_inv hba hac⟩
 
 /-- If `r` is invertible and `s = r`, then `s` is invertible. -/
 def Invertible.copy [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (hs : s = r) : Invertible s

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -97,76 +97,34 @@ theorem mul_invOf_self [Mul α] [One α] (a : α) [Invertible a] : a * ⅟ a = 1
 #align mul_inv_of_self mul_invOf_self
 -/
 
-/- warning: inv_of_mul_self_assoc -> invOf_mul_self_assoc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a], Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a b)) b
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a], Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a b)) b
-Case conversion may be inaccurate. Consider using '#align inv_of_mul_self_assoc invOf_mul_self_assocₓ'. -/
 @[simp]
 theorem invOf_mul_self_assoc [Monoid α] (a b : α) [Invertible a] : ⅟ a * (a * b) = b := by
   rw [← mul_assoc, invOf_mul_self, one_mul]
 #align inv_of_mul_self_assoc invOf_mul_self_assoc
 
-/- warning: mul_inv_of_self_assoc -> mul_invOf_self_assoc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a], Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a _inst_2) b)) b
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a], Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a _inst_2) b)) b
-Case conversion may be inaccurate. Consider using '#align mul_inv_of_self_assoc mul_invOf_self_assocₓ'. -/
 @[simp]
 theorem mul_invOf_self_assoc [Monoid α] (a b : α) [Invertible a] : a * (⅟ a * b) = b := by
   rw [← mul_assoc, mul_invOf_self, one_mul]
 #align mul_inv_of_self_assoc mul_invOf_self_assoc
 
-/- warning: mul_inv_of_mul_self_cancel -> mul_invOf_mul_self_cancel is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b], 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 (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b _inst_2)) b) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b], 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 (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b _inst_2)) b) a
-Case conversion may be inaccurate. Consider using '#align mul_inv_of_mul_self_cancel mul_invOf_mul_self_cancelₓ'. -/
 @[simp]
 theorem mul_invOf_mul_self_cancel [Monoid α] (a b : α) [Invertible b] : a * ⅟ b * b = a := by
   simp [mul_assoc]
 #align mul_inv_of_mul_self_cancel mul_invOf_mul_self_cancel
 
-/- warning: mul_mul_inv_of_self_cancel -> mul_mul_invOf_self_cancel is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b], 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 b) (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b _inst_2)) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b], 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 b) (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b _inst_2)) a
-Case conversion may be inaccurate. Consider using '#align mul_mul_inv_of_self_cancel mul_mul_invOf_self_cancelₓ'. -/
 @[simp]
 theorem mul_mul_invOf_self_cancel [Monoid α] (a b : α) [Invertible b] : a * b * ⅟ b = a := by
   simp [mul_assoc]
 #align mul_mul_inv_of_self_cancel mul_mul_invOf_self_cancel
 
-/- warning: inv_of_eq_right_inv -> invOf_eq_right_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} {b : α} [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a], (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)))))) -> (Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a _inst_2) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} {b : α} [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a], (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)))) -> (Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a _inst_2) b)
-Case conversion may be inaccurate. Consider using '#align inv_of_eq_right_inv invOf_eq_right_invₓ'. -/
 theorem invOf_eq_right_inv [Monoid α] {a b : α} [Invertible a] (hac : a * b = 1) : ⅟ a = b :=
   left_inv_eq_right_inv (invOf_mul_self _) hac
 #align inv_of_eq_right_inv invOf_eq_right_inv
 
-/- warning: inv_of_eq_left_inv -> invOf_eq_left_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} {b : α} [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a], (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} α (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a _inst_2) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} {b : α} [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a], (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} α (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a _inst_2) b)
-Case conversion may be inaccurate. Consider using '#align inv_of_eq_left_inv invOf_eq_left_invₓ'. -/
 theorem invOf_eq_left_inv [Monoid α] {a b : α} [Invertible a] (hac : b * a = 1) : ⅟ a = b :=
   (left_inv_eq_right_inv hac (mul_invOf_self _)).symm
 #align inv_of_eq_left_inv invOf_eq_left_inv
 
-/- warning: invertible_unique -> invertible_unique is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a] [_inst_3 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b], (Eq.{succ u1} α a b) -> (Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a _inst_2) (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b _inst_3))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a] [_inst_3 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b], (Eq.{succ u1} α a b) -> (Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a _inst_2) (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b _inst_3))
-Case conversion may be inaccurate. Consider using '#align invertible_unique invertible_uniqueₓ'. -/
 theorem invertible_unique {α : Type u} [Monoid α] (a b : α) [Invertible a] [Invertible b]
     (h : a = b) : ⅟ a = ⅟ b := by apply invOf_eq_right_inv; rw [h, mul_invOf_self]
 #align invertible_unique invertible_unique
@@ -174,12 +132,6 @@ theorem invertible_unique {α : Type u} [Monoid α] (a b : α) [Invertible a] [I
 instance [Monoid α] (a : α) : Subsingleton (Invertible a) :=
   ⟨fun ⟨b, hba, hab⟩ ⟨c, hca, hac⟩ => by congr ; exact left_inv_eq_right_inv hba hac⟩
 
-/- warning: invertible.copy -> Invertible.copy is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α] {r : α}, (Invertible.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) (MulOneClass.toHasOne.{u1} α _inst_1) r) -> (forall (s : α), (Eq.{succ u1} α s r) -> (Invertible.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) (MulOneClass.toHasOne.{u1} α _inst_1) s))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α] {r : α}, (Invertible.{u1} α (MulOneClass.toMul.{u1} α _inst_1) (MulOneClass.toOne.{u1} α _inst_1) r) -> (forall (s : α), (Eq.{succ u1} α s r) -> (Invertible.{u1} α (MulOneClass.toMul.{u1} α _inst_1) (MulOneClass.toOne.{u1} α _inst_1) s))
-Case conversion may be inaccurate. Consider using '#align invertible.copy Invertible.copyₓ'. -/
 /-- If `r` is invertible and `s = r`, then `s` is invertible. -/
 def Invertible.copy [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (hs : s = r) : Invertible s
     where
@@ -188,12 +140,6 @@ def Invertible.copy [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (hs :
   mul_invOf_self := by rw [hs, mul_invOf_self]
 #align invertible.copy Invertible.copy
 
-/- warning: unit_of_invertible -> unitOfInvertible is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a], Units.{u1} α _inst_1
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a], Units.{u1} α _inst_1
-Case conversion may be inaccurate. Consider using '#align unit_of_invertible unitOfInvertibleₓ'. -/
 /-- An `invertible` element is a unit. -/
 @[simps]
 def unitOfInvertible [Monoid α] (a : α) [Invertible a] : αˣ
@@ -204,22 +150,10 @@ def unitOfInvertible [Monoid α] (a : α) [Invertible a] : αˣ
   inv_val := by simp
 #align unit_of_invertible unitOfInvertible
 
-/- warning: is_unit_of_invertible -> isUnit_of_invertible is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a], IsUnit.{u1} α _inst_1 a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a], IsUnit.{u1} α _inst_1 a
-Case conversion may be inaccurate. Consider using '#align is_unit_of_invertible isUnit_of_invertibleₓ'. -/
 theorem isUnit_of_invertible [Monoid α] (a : α) [Invertible a] : IsUnit a :=
   ⟨unitOfInvertible a, rfl⟩
 #align is_unit_of_invertible isUnit_of_invertible
 
-/- warning: units.invertible -> Units.invertible is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1), Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{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)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1), Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (Units.val.{u1} α _inst_1 u)
-Case conversion may be inaccurate. Consider using '#align units.invertible Units.invertibleₓ'. -/
 /-- Units are invertible in their associated monoid. -/
 def Units.invertible [Monoid α] (u : αˣ) : Invertible (u : α)
     where
@@ -228,34 +162,16 @@ def Units.invertible [Monoid α] (u : αˣ) : Invertible (u : α)
   mul_invOf_self := u.mul_inv
 #align units.invertible Units.invertible
 
-/- warning: inv_of_units -> invOf_units is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1) [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{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)], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{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) _inst_2) ((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) [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (Units.val.{u1} α _inst_1 u)], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (Units.val.{u1} α _inst_1 u) _inst_2) (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 inv_of_units invOf_unitsₓ'. -/
 @[simp]
 theorem invOf_units [Monoid α] (u : αˣ) [Invertible (u : α)] : ⅟ (u : α) = ↑u⁻¹ :=
   invOf_eq_right_inv u.mul_inv
 #align inv_of_units invOf_units
 
-/- warning: is_unit.nonempty_invertible -> IsUnit.nonempty_invertible is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α}, (IsUnit.{u1} α _inst_1 a) -> (Nonempty.{succ u1} (Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α}, (IsUnit.{u1} α _inst_1 a) -> (Nonempty.{succ u1} (Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a))
-Case conversion may be inaccurate. Consider using '#align is_unit.nonempty_invertible IsUnit.nonempty_invertibleₓ'. -/
 theorem IsUnit.nonempty_invertible [Monoid α] {a : α} (h : IsUnit a) : Nonempty (Invertible a) :=
   let ⟨x, hx⟩ := h
   ⟨x.Invertible.copy _ hx.symm⟩
 #align is_unit.nonempty_invertible IsUnit.nonempty_invertible
 
-/- warning: is_unit.invertible -> IsUnit.invertible is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α}, (IsUnit.{u1} α _inst_1 a) -> (Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α}, (IsUnit.{u1} α _inst_1 a) -> (Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align is_unit.invertible IsUnit.invertibleₓ'. -/
 /-- Convert `is_unit` to `invertible` using `classical.choice`.
 
 Prefer `casesI h.nonempty_invertible` over `letI := h.invertible` if you want to avoid choice. -/
@@ -263,102 +179,48 @@ noncomputable def IsUnit.invertible [Monoid α] {a : α} (h : IsUnit a) : Invert
   Classical.choice h.nonempty_invertible
 #align is_unit.invertible IsUnit.invertible
 
-/- warning: nonempty_invertible_iff_is_unit -> nonempty_invertible_iff_isUnit is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α), Iff (Nonempty.{succ u1} (Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a)) (IsUnit.{u1} α _inst_1 a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α), Iff (Nonempty.{succ u1} (Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a)) (IsUnit.{u1} α _inst_1 a)
-Case conversion may be inaccurate. Consider using '#align nonempty_invertible_iff_is_unit nonempty_invertible_iff_isUnitₓ'. -/
 @[simp]
 theorem nonempty_invertible_iff_isUnit [Monoid α] (a : α) : Nonempty (Invertible a) ↔ IsUnit a :=
   ⟨Nonempty.ndrec <| @isUnit_of_invertible _ _ _, IsUnit.nonempty_invertible⟩
 #align nonempty_invertible_iff_is_unit nonempty_invertible_iff_isUnit
 
-/- warning: invertible_of_group -> invertibleOfGroup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (a : α), Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (a : α), Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a
-Case conversion may be inaccurate. Consider using '#align invertible_of_group invertibleOfGroupₓ'. -/
 /-- Each element of a group is invertible. -/
 def invertibleOfGroup [Group α] (a : α) : Invertible a :=
   ⟨a⁻¹, inv_mul_self a, mul_inv_self a⟩
 #align invertible_of_group invertibleOfGroup
 
-/- warning: inv_of_eq_group_inv -> invOf_eq_group_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (a : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) a], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) a _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (a : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a _inst_2) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a)
-Case conversion may be inaccurate. Consider using '#align inv_of_eq_group_inv invOf_eq_group_invₓ'. -/
 @[simp]
 theorem invOf_eq_group_inv [Group α] (a : α) [Invertible a] : ⅟ a = a⁻¹ :=
   invOf_eq_right_inv (mul_inv_self a)
 #align inv_of_eq_group_inv invOf_eq_group_inv
 
-/- warning: invertible_one -> invertibleOne is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{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} α], Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align invertible_one invertibleOneₓ'. -/
 /-- `1` is the inverse of itself -/
 def invertibleOne [Monoid α] : Invertible (1 : α) :=
   ⟨1, mul_one _, one_mul _⟩
 #align invertible_one invertibleOne
 
-/- warning: inv_of_one -> invOf_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))))) _inst_2) (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} α] [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))) _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align inv_of_one invOf_oneₓ'. -/
 @[simp]
 theorem invOf_one [Monoid α] [Invertible (1 : α)] : ⅟ (1 : α) = 1 :=
   invOf_eq_right_inv (mul_one _)
 #align inv_of_one invOf_one
 
-/- warning: invertible_neg -> invertibleNeg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : One.{u1} α] [_inst_3 : HasDistribNeg.{u1} α _inst_1] (a : α) [_inst_4 : Invertible.{u1} α _inst_1 _inst_2 a], Invertible.{u1} α _inst_1 _inst_2 (Neg.neg.{u1} α (InvolutiveNeg.toHasNeg.{u1} α (HasDistribNeg.toHasInvolutiveNeg.{u1} α _inst_1 _inst_3)) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : One.{u1} α] [_inst_3 : HasDistribNeg.{u1} α _inst_1] (a : α) [_inst_4 : Invertible.{u1} α _inst_1 _inst_2 a], Invertible.{u1} α _inst_1 _inst_2 (Neg.neg.{u1} α (InvolutiveNeg.toNeg.{u1} α (HasDistribNeg.toInvolutiveNeg.{u1} α _inst_1 _inst_3)) a)
-Case conversion may be inaccurate. Consider using '#align invertible_neg invertibleNegₓ'. -/
 /-- `-⅟a` is the inverse of `-a` -/
 def invertibleNeg [Mul α] [One α] [HasDistribNeg α] (a : α) [Invertible a] : Invertible (-a) :=
   ⟨-⅟ a, by simp, by simp⟩
 #align invertible_neg invertibleNeg
 
-/- warning: inv_of_neg -> invOf_neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] [_inst_2 : HasDistribNeg.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))] (a : α) [_inst_3 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a] [_inst_4 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Neg.neg.{u1} α (InvolutiveNeg.toHasNeg.{u1} α (HasDistribNeg.toHasInvolutiveNeg.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) _inst_2)) a)], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Neg.neg.{u1} α (InvolutiveNeg.toHasNeg.{u1} α (HasDistribNeg.toHasInvolutiveNeg.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) _inst_2)) a) _inst_4) (Neg.neg.{u1} α (InvolutiveNeg.toHasNeg.{u1} α (HasDistribNeg.toHasInvolutiveNeg.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) _inst_2)) (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a _inst_3))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] [_inst_2 : HasDistribNeg.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))] (a : α) [_inst_3 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a] [_inst_4 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (Neg.neg.{u1} α (InvolutiveNeg.toNeg.{u1} α (HasDistribNeg.toInvolutiveNeg.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) _inst_2)) a)], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (Neg.neg.{u1} α (InvolutiveNeg.toNeg.{u1} α (HasDistribNeg.toInvolutiveNeg.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) _inst_2)) a) _inst_4) (Neg.neg.{u1} α (InvolutiveNeg.toNeg.{u1} α (HasDistribNeg.toInvolutiveNeg.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) _inst_2)) (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a _inst_3))
-Case conversion may be inaccurate. Consider using '#align inv_of_neg invOf_negₓ'. -/
 @[simp]
 theorem invOf_neg [Monoid α] [HasDistribNeg α] (a : α) [Invertible a] [Invertible (-a)] :
     ⅟ (-a) = -⅟ a :=
   invOf_eq_right_inv (by simp)
 #align inv_of_neg invOf_neg
 
-/- warning: one_sub_inv_of_two -> one_sub_invOf_two is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Ring.{u1} α] [_inst_2 : Invertible.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))))], Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))) (Invertible.invOf.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))))) _inst_2)) (Invertible.invOf.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))))) _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Ring.{u1} α] [_inst_2 : Invertible.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))) (Semiring.toOne.{u1} α (Ring.toSemiring.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (Semiring.toNatCast.{u1} α (Ring.toSemiring.{u1} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))], Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (Ring.toSub.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Semiring.toOne.{u1} α (Ring.toSemiring.{u1} α _inst_1)))) (Invertible.invOf.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))) (Semiring.toOne.{u1} α (Ring.toSemiring.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (Semiring.toNatCast.{u1} α (Ring.toSemiring.{u1} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) _inst_2)) (Invertible.invOf.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))) (Semiring.toOne.{u1} α (Ring.toSemiring.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (Semiring.toNatCast.{u1} α (Ring.toSemiring.{u1} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) _inst_2)
-Case conversion may be inaccurate. Consider using '#align one_sub_inv_of_two one_sub_invOf_twoₓ'. -/
 @[simp]
 theorem one_sub_invOf_two [Ring α] [Invertible (2 : α)] : 1 - (⅟ 2 : α) = ⅟ 2 :=
   (isUnit_of_invertible (2 : α)).mul_right_inj.1 <| by
     rw [mul_sub, mul_invOf_self, mul_one, bit0, add_sub_cancel]
 #align one_sub_inv_of_two one_sub_invOf_two
 
-/- warning: inv_of_two_add_inv_of_two -> invOf_two_add_invOf_two is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NonAssocSemiring.{u1} α] [_inst_2 : Invertible.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α _inst_1)))))))], Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α _inst_1)))) (Invertible.invOf.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α _inst_1))))))) _inst_2) (Invertible.invOf.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α _inst_1))))))) _inst_2)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NonAssocSemiring.{u1} α] [_inst_2 : Invertible.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α _inst_1)) (NonAssocSemiring.toOne.{u1} α _inst_1) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (NonAssocSemiring.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))], Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α _inst_1)))) (Invertible.invOf.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α _inst_1)) (NonAssocSemiring.toOne.{u1} α _inst_1) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (NonAssocSemiring.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) _inst_2) (Invertible.invOf.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α _inst_1)) (NonAssocSemiring.toOne.{u1} α _inst_1) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (NonAssocSemiring.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) _inst_2)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (NonAssocSemiring.toOne.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align inv_of_two_add_inv_of_two invOf_two_add_invOf_twoₓ'. -/
 @[simp]
 theorem invOf_two_add_invOf_two [NonAssocSemiring α] [Invertible (2 : α)] :
     (⅟ 2 : α) + (⅟ 2 : α) = 1 := by rw [← two_mul, mul_invOf_self]
@@ -371,57 +233,27 @@ instance invertibleInvOf [One α] [Mul α] {a : α} [Invertible a] : Invertible
 #align invertible_inv_of invertibleInvOf
 -/
 
-/- warning: inv_of_inv_of -> invOf_invOf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a] [_inst_3 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a _inst_2)], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a _inst_2) _inst_3) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a] [_inst_3 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a _inst_2)], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a _inst_2) _inst_3) a
-Case conversion may be inaccurate. Consider using '#align inv_of_inv_of invOf_invOfₓ'. -/
 @[simp]
 theorem invOf_invOf [Monoid α] (a : α) [Invertible a] [Invertible (⅟ a)] : ⅟ (⅟ a) = a :=
   invOf_eq_right_inv (invOf_mul_self _)
 #align inv_of_inv_of invOf_invOf
 
-/- warning: inv_of_inj -> invOf_inj is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} {b : α} [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a] [_inst_3 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b], Iff (Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a _inst_2) (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b _inst_3)) (Eq.{succ u1} α a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} {b : α} [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a] [_inst_3 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b], Iff (Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a _inst_2) (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b _inst_3)) (Eq.{succ u1} α a b)
-Case conversion may be inaccurate. Consider using '#align inv_of_inj invOf_injₓ'. -/
 @[simp]
 theorem invOf_inj [Monoid α] {a b : α} [Invertible a] [Invertible b] : ⅟ a = ⅟ b ↔ a = b :=
   ⟨invertible_unique _ _, invertible_unique _ _⟩
 #align inv_of_inj invOf_inj
 
-/- warning: invertible_mul -> invertibleMul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a] [_inst_3 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b], Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a] [_inst_3 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b], Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a b)
-Case conversion may be inaccurate. Consider using '#align invertible_mul invertibleMulₓ'. -/
 /-- `⅟b * ⅟a` is the inverse of `a * b` -/
 def invertibleMul [Monoid α] (a b : α) [Invertible a] [Invertible b] : Invertible (a * b) :=
   ⟨⅟ b * ⅟ a, by simp [← mul_assoc], by simp [← mul_assoc]⟩
 #align invertible_mul invertibleMul
 
-/- warning: inv_of_mul -> invOf_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a] [_inst_3 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b] [_inst_4 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a b)], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a b) _inst_4) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b _inst_3) (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a] [_inst_3 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b] [_inst_4 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a b)], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) a b) _inst_4) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b _inst_3) (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a _inst_2))
-Case conversion may be inaccurate. Consider using '#align inv_of_mul invOf_mulₓ'. -/
 @[simp]
 theorem invOf_mul [Monoid α] (a b : α) [Invertible a] [Invertible b] [Invertible (a * b)] :
     ⅟ (a * b) = ⅟ b * ⅟ a :=
   invOf_eq_right_inv (by simp [← mul_assoc])
 #align inv_of_mul invOf_mul
 
-/- warning: commute.inv_of_right -> Commute.invOf_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} {b : α} [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b], (Commute.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a b) -> (Commute.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} {b : α} [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b], (Commute.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a b) -> (Commute.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) a (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b _inst_2))
-Case conversion may be inaccurate. Consider using '#align commute.inv_of_right Commute.invOf_rightₓ'. -/
 theorem Commute.invOf_right [Monoid α] {a b : α} [Invertible b] (h : Commute a b) :
     Commute a (⅟ b) :=
   calc
@@ -431,12 +263,6 @@ theorem Commute.invOf_right [Monoid α] {a b : α} [Invertible b] (h : Commute a
     
 #align commute.inv_of_right Commute.invOf_right
 
-/- warning: commute.inv_of_left -> Commute.invOf_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} {b : α} [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b], (Commute.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b a) -> (Commute.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b _inst_2) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {a : α} {b : α} [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b], (Commute.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) b a) -> (Commute.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b _inst_2) a)
-Case conversion may be inaccurate. Consider using '#align commute.inv_of_left Commute.invOf_leftₓ'. -/
 theorem Commute.invOf_left [Monoid α] {a b : α} [Invertible b] (h : Commute b a) :
     Commute (⅟ b) a :=
   calc
@@ -455,12 +281,6 @@ theorem commute_invOf {M : Type _} [One M] [Mul M] (m : M) [Invertible m] : Comm
 #align commute_inv_of commute_invOf
 -/
 
-/- warning: nonzero_of_invertible -> nonzero_of_invertible is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroOneClass.{u1} α] (a : α) [_inst_2 : Nontrivial.{u1} α] [_inst_3 : Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α _inst_1)) a], Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulZeroOneClass.{u1} α] (a : α) [_inst_2 : Nontrivial.{u1} α] [_inst_3 : Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α _inst_1)) (MulOneClass.toOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α _inst_1)) a], Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroOneClass.toZero.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align nonzero_of_invertible nonzero_of_invertibleₓ'. -/
 theorem nonzero_of_invertible [MulZeroOneClass α] (a : α) [Nontrivial α] [Invertible a] : a ≠ 0 :=
   fun ha =>
   zero_ne_one <|
@@ -470,12 +290,6 @@ theorem nonzero_of_invertible [MulZeroOneClass α] (a : α) [Nontrivial α] [Inv
       
 #align nonzero_of_invertible nonzero_of_invertible
 
-/- warning: invertible.ne_zero -> Invertible.ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroOneClass.{u1} α] [_inst_2 : Nontrivial.{u1} α] (a : α) [_inst_3 : Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α _inst_1)) a], NeZero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α _inst_1)) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulZeroOneClass.{u1} α] [_inst_2 : Nontrivial.{u1} α] (a : α) [_inst_3 : Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α _inst_1)) (MulOneClass.toOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α _inst_1)) a], NeZero.{u1} α (MulZeroOneClass.toZero.{u1} α _inst_1) a
-Case conversion may be inaccurate. Consider using '#align invertible.ne_zero Invertible.ne_zeroₓ'. -/
 instance (priority := 100) Invertible.ne_zero [MulZeroOneClass α] [Nontrivial α] (a : α)
     [Invertible a] : NeZero a :=
   ⟨nonzero_of_invertible a⟩
@@ -485,12 +299,6 @@ section MonoidWithZero
 
 variable [MonoidWithZero α]
 
-/- warning: ring.inverse_invertible -> Ring.inverse_invertible is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} α] (x : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α _inst_1))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α _inst_1))) x], Eq.{succ u1} α (Ring.inverse.{u1} α _inst_1 x) (Invertible.invOf.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α _inst_1))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α _inst_1))) x _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} α] (x : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α _inst_1))) (Monoid.toOne.{u1} α (MonoidWithZero.toMonoid.{u1} α _inst_1)) x], Eq.{succ u1} α (Ring.inverse.{u1} α _inst_1 x) (Invertible.invOf.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α _inst_1))) (Monoid.toOne.{u1} α (MonoidWithZero.toMonoid.{u1} α _inst_1)) x _inst_2)
-Case conversion may be inaccurate. Consider using '#align ring.inverse_invertible Ring.inverse_invertibleₓ'. -/
 /-- A variant of `ring.inverse_unit`. -/
 @[simp]
 theorem Ring.inverse_invertible (x : α) [Invertible x] : Ring.inverse x = ⅟ x :=
@@ -503,112 +311,52 @@ section GroupWithZero
 
 variable [GroupWithZero α]
 
-/- warning: invertible_of_nonzero -> invertibleOfNonzero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))) -> (Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) -> (Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) a)
-Case conversion may be inaccurate. Consider using '#align invertible_of_nonzero invertibleOfNonzeroₓ'. -/
 /-- `a⁻¹` is an inverse of `a` if `a ≠ 0` -/
 def invertibleOfNonzero {a : α} (h : a ≠ 0) : Invertible a :=
   ⟨a⁻¹, inv_mul_cancel h, mul_inv_cancel h⟩
 #align invertible_of_nonzero invertibleOfNonzero
 
-/- warning: inv_of_eq_inv -> invOf_eq_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] (a : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) a], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) a _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1)) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] (a : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) a], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) a _inst_2) (Inv.inv.{u1} α (GroupWithZero.toInv.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align inv_of_eq_inv invOf_eq_invₓ'. -/
 @[simp]
 theorem invOf_eq_inv (a : α) [Invertible a] : ⅟ a = a⁻¹ :=
   invOf_eq_right_inv (mul_inv_cancel (nonzero_of_invertible a))
 #align inv_of_eq_inv invOf_eq_inv
 
-/- warning: inv_mul_cancel_of_invertible -> inv_mul_cancel_of_invertible is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] (a : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) a], Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1)) a) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] (a : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) a], Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) (Inv.inv.{u1} α (GroupWithZero.toInv.{u1} α _inst_1) a) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align inv_mul_cancel_of_invertible inv_mul_cancel_of_invertibleₓ'. -/
 @[simp]
 theorem inv_mul_cancel_of_invertible (a : α) [Invertible a] : a⁻¹ * a = 1 :=
   inv_mul_cancel (nonzero_of_invertible a)
 #align inv_mul_cancel_of_invertible inv_mul_cancel_of_invertible
 
-/- warning: mul_inv_cancel_of_invertible -> mul_inv_cancel_of_invertible is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] (a : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) a], Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1)) a)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] (a : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) a], Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) a (Inv.inv.{u1} α (GroupWithZero.toInv.{u1} α _inst_1) a)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align mul_inv_cancel_of_invertible mul_inv_cancel_of_invertibleₓ'. -/
 @[simp]
 theorem mul_inv_cancel_of_invertible (a : α) [Invertible a] : a * a⁻¹ = 1 :=
   mul_inv_cancel (nonzero_of_invertible a)
 #align mul_inv_cancel_of_invertible mul_inv_cancel_of_invertible
 
-/- warning: div_mul_cancel_of_invertible -> div_mul_cancel_of_invertible is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) b], Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1))) a b) b) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) b], Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (GroupWithZero.toDiv.{u1} α _inst_1)) a b) b) a
-Case conversion may be inaccurate. Consider using '#align div_mul_cancel_of_invertible div_mul_cancel_of_invertibleₓ'. -/
 @[simp]
 theorem div_mul_cancel_of_invertible (a b : α) [Invertible b] : a / b * b = a :=
   div_mul_cancel a (nonzero_of_invertible b)
 #align div_mul_cancel_of_invertible div_mul_cancel_of_invertible
 
-/- warning: mul_div_cancel_of_invertible -> mul_div_cancel_of_invertible is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) b], Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) a b) b) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) b], Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (GroupWithZero.toDiv.{u1} α _inst_1)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) a b) b) a
-Case conversion may be inaccurate. Consider using '#align mul_div_cancel_of_invertible mul_div_cancel_of_invertibleₓ'. -/
 @[simp]
 theorem mul_div_cancel_of_invertible (a b : α) [Invertible b] : a * b / b = a :=
   mul_div_cancel a (nonzero_of_invertible b)
 #align mul_div_cancel_of_invertible mul_div_cancel_of_invertible
 
-/- warning: div_self_of_invertible -> div_self_of_invertible is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] (a : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) a], Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1))) a a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] (a : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) a], Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (GroupWithZero.toDiv.{u1} α _inst_1)) a a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align div_self_of_invertible div_self_of_invertibleₓ'. -/
 @[simp]
 theorem div_self_of_invertible (a : α) [Invertible a] : a / a = 1 :=
   div_self (nonzero_of_invertible a)
 #align div_self_of_invertible div_self_of_invertible
 
-/- warning: invertible_div -> invertibleDiv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) a] [_inst_3 : Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) b], Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1))) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) a] [_inst_3 : Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) b], Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (GroupWithZero.toDiv.{u1} α _inst_1)) a b)
-Case conversion may be inaccurate. Consider using '#align invertible_div invertibleDivₓ'. -/
 /-- `b / a` is the inverse of `a / b` -/
 def invertibleDiv (a b : α) [Invertible a] [Invertible b] : Invertible (a / b) :=
   ⟨b / a, by simp [← mul_div_assoc], by simp [← mul_div_assoc]⟩
 #align invertible_div invertibleDiv
 
-/- warning: inv_of_div -> invOf_div is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) a] [_inst_3 : Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) b] [_inst_4 : Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1))) a b)], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1))) a b) _inst_4) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1))) b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) a] [_inst_3 : Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) b] [_inst_4 : Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (GroupWithZero.toDiv.{u1} α _inst_1)) a b)], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (GroupWithZero.toDiv.{u1} α _inst_1)) a b) _inst_4) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (GroupWithZero.toDiv.{u1} α _inst_1)) b a)
-Case conversion may be inaccurate. Consider using '#align inv_of_div invOf_divₓ'. -/
 @[simp]
 theorem invOf_div (a b : α) [Invertible a] [Invertible b] [Invertible (a / b)] :
     ⅟ (a / b) = b / a :=
   invOf_eq_right_inv (by simp [← mul_div_assoc])
 #align inv_of_div invOf_div
 
-/- warning: invertible_inv -> invertibleInv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] {a : α} [_inst_2 : Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) a], Invertible.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (MulZeroOneClass.toMulOneClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1)) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] {a : α} [_inst_2 : Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) a], Invertible.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (GroupWithZero.toDivisionMonoid.{u1} α _inst_1)))) (Inv.inv.{u1} α (GroupWithZero.toInv.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align invertible_inv invertibleInvₓ'. -/
 /-- `a` is the inverse of `a⁻¹` -/
 def invertibleInv {a : α} [Invertible a] : Invertible a⁻¹ :=
   ⟨a, by simp, by simp⟩
@@ -616,12 +364,6 @@ def invertibleInv {a : α} [Invertible a] : Invertible a⁻¹ :=
 
 end GroupWithZero
 
-/- warning: invertible.map -> Invertible.map is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S _inst_1 _inst_2] (f : F) (r : R) [_inst_4 : Invertible.{u1} R (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasOne.{u1} R _inst_1) r], Invertible.{u2} S (MulOneClass.toHasMul.{u2} S _inst_2) (MulOneClass.toHasOne.{u2} S _inst_2) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasMul.{u2} S _inst_2) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 _inst_2 _inst_3))) f r)
-but is expected to have type
-  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S _inst_1 _inst_2] (f : F) (r : R) [_inst_4 : Invertible.{u1} R (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toOne.{u1} R _inst_1) r], Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) _inst_2) (MulOneClass.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) _inst_2) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toMul.{u2} S _inst_2) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 _inst_2 _inst_3)) f r)
-Case conversion may be inaccurate. Consider using '#align invertible.map Invertible.mapₓ'. -/
 /-- Monoid homs preserve invertibility. -/
 def Invertible.map {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [MulOneClass S]
     [MonoidHomClass F R S] (f : F) (r : R) [Invertible r] : Invertible (f r)
@@ -631,12 +373,6 @@ def Invertible.map {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [MulOn
   mul_invOf_self := by rw [← map_mul, mul_invOf_self, map_one]
 #align invertible.map Invertible.map
 
-/- warning: map_inv_of -> map_invOf is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2)] (f : F) (r : R) [_inst_4 : Invertible.{u1} R (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasOne.{u1} R _inst_1) r] [_inst_5 : Invertible.{u2} S (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toHasOne.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f r)], Eq.{succ u2} S (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f (Invertible.invOf.{u1} R (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasOne.{u1} R _inst_1) r _inst_4)) (Invertible.invOf.{u2} S (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toHasOne.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f r) _inst_5)
-but is expected to have type
-  forall {R : Type.{u3}} {S : Type.{u2}} {F : Type.{u1}} [_inst_1 : MulOneClass.{u3} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2)] (f : F) (r : R) [_inst_4 : Invertible.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r] [_inst_5 : Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) _inst_2) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r)], Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) (Invertible.invOf.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r _inst_4)) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f (Invertible.invOf.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r _inst_4)) (Invertible.invOf.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) _inst_2) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r) _inst_5)
-Case conversion may be inaccurate. Consider using '#align map_inv_of map_invOfₓ'. -/
 /-- Note that the `invertible (f r)` argument can be satisfied by using `letI := invertible.map f r`
 before applying this lemma. -/
 theorem map_invOf {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [Monoid S]
@@ -644,12 +380,6 @@ theorem map_invOf {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [Monoid
   by letI := Invertible.map f r; convert rfl
 #align map_inv_of map_invOf
 
-/- warning: invertible.of_left_inverse -> Invertible.ofLeftInverse is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} {G : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u2, u1} G S R _inst_2 _inst_1] (f : R -> S) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (coeFn.{succ u3, max (succ u2) (succ u1)} G (fun (_x : G) => S -> R) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} G S (fun (_x : S) => R) (MulHomClass.toFunLike.{u3, u2, u1} G S R (MulOneClass.toHasMul.{u2} S _inst_2) (MulOneClass.toHasMul.{u1} R _inst_1) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G S R _inst_2 _inst_1 _inst_3))) g) f) -> (forall [_inst_4 : Invertible.{u2} S (MulOneClass.toHasMul.{u2} S _inst_2) (MulOneClass.toHasOne.{u2} S _inst_2) (f r)], Invertible.{u1} R (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasOne.{u1} R _inst_1) r)
-but is expected to have type
-  forall {R : Type.{u1}} {S : Type.{u2}} {G : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u2, u1} G S R _inst_2 _inst_1] (f : R -> S) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (FunLike.coe.{succ u3, succ u2, succ u1} G S (fun (_x : S) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : S) => R) _x) (MulHomClass.toFunLike.{u3, u2, u1} G S R (MulOneClass.toMul.{u2} S _inst_2) (MulOneClass.toMul.{u1} R _inst_1) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G S R _inst_2 _inst_1 _inst_3)) g) f) -> (forall [_inst_4 : Invertible.{u2} S (MulOneClass.toMul.{u2} S _inst_2) (MulOneClass.toOne.{u2} S _inst_2) (f r)], Invertible.{u1} R (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toOne.{u1} R _inst_1) r)
-Case conversion may be inaccurate. Consider using '#align invertible.of_left_inverse Invertible.ofLeftInverseₓ'. -/
 /-- If a function `f : R → S` has a left-inverse that is a monoid hom,
   then `r : R` is invertible if `f r` is.
 
@@ -661,12 +391,6 @@ def Invertible.ofLeftInverse {R : Type _} {S : Type _} {G : Type _} [MulOneClass
   (Invertible.map g (f r)).copy _ (h r).symm
 #align invertible.of_left_inverse Invertible.ofLeftInverse
 
-/- warning: invertible_equiv_of_left_inverse -> invertibleEquivOfLeftInverse is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : Monoid.{u1} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2)] [_inst_4 : MonoidHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1)] (f : F) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (coeFn.{succ u4, max (succ u2) (succ u1)} G (fun (_x : G) => S -> R) (FunLike.hasCoeToFun.{succ u4, succ u2, succ u1} G S (fun (_x : S) => R) (MulHomClass.toFunLike.{u4, u2, u1} G S R (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MonoidHomClass.toMulHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) _inst_4))) g) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f)) -> (Equiv.{succ u2, succ u1} (Invertible.{u2} S (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toHasOne.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f r)) (Invertible.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toHasOne.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) r))
-but is expected to have type
-  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : Monoid.{u1} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2)] [_inst_4 : MonoidHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1)] (f : F) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (FunLike.coe.{succ u4, succ u2, succ u1} G S (fun (_x : S) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : S) => R) _x) (MulHomClass.toFunLike.{u4, u2, u1} G S R (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MonoidHomClass.toMulHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) _inst_4)) g) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f)) -> (Equiv.{succ u2, succ u1} (Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) _inst_2) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r)) (Invertible.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (Monoid.toOne.{u1} R _inst_1) r))
-Case conversion may be inaccurate. Consider using '#align invertible_equiv_of_left_inverse invertibleEquivOfLeftInverseₓ'. -/
 /-- Invertibility on either side of a monoid hom with a left-inverse is equivalent. -/
 @[simps]
 def invertibleEquivOfLeftInverse {R : Type _} {S : Type _} {F G : Type _} [Monoid R] [Monoid S]

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -168,15 +168,11 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (a : α) (b : α) [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a] [_inst_3 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b], (Eq.{succ u1} α a b) -> (Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) a _inst_2) (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) b _inst_3))
 Case conversion may be inaccurate. Consider using '#align invertible_unique invertible_uniqueₓ'. -/
 theorem invertible_unique {α : Type u} [Monoid α] (a b : α) [Invertible a] [Invertible b]
-    (h : a = b) : ⅟ a = ⅟ b := by
-  apply invOf_eq_right_inv
-  rw [h, mul_invOf_self]
+    (h : a = b) : ⅟ a = ⅟ b := by apply invOf_eq_right_inv; rw [h, mul_invOf_self]
 #align invertible_unique invertible_unique
 
 instance [Monoid α] (a : α) : Subsingleton (Invertible a) :=
-  ⟨fun ⟨b, hba, hab⟩ ⟨c, hca, hac⟩ => by
-    congr
-    exact left_inv_eq_right_inv hba hac⟩
+  ⟨fun ⟨b, hba, hab⟩ ⟨c, hca, hac⟩ => by congr ; exact left_inv_eq_right_inv hba hac⟩
 
 /- warning: invertible.copy -> Invertible.copy is a dubious translation:
 lean 3 declaration is
@@ -645,9 +641,7 @@ Case conversion may be inaccurate. Consider using '#align map_inv_of map_invOf
 before applying this lemma. -/
 theorem map_invOf {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [Monoid S]
     [MonoidHomClass F R S] (f : F) (r : R) [Invertible r] [Invertible (f r)] : f (⅟ r) = ⅟ (f r) :=
-  by
-  letI := Invertible.map f r
-  convert rfl
+  by letI := Invertible.map f r; convert rfl
 #align map_inv_of map_invOf
 
 /- warning: invertible.of_left_inverse -> Invertible.ofLeftInverse is a dubious translation:

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -624,7 +624,7 @@ end GroupWithZero
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S _inst_1 _inst_2] (f : F) (r : R) [_inst_4 : Invertible.{u1} R (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasOne.{u1} R _inst_1) r], Invertible.{u2} S (MulOneClass.toHasMul.{u2} S _inst_2) (MulOneClass.toHasOne.{u2} S _inst_2) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasMul.{u2} S _inst_2) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 _inst_2 _inst_3))) f r)
 but is expected to have type
-  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S _inst_1 _inst_2] (f : F) (r : R) [_inst_4 : Invertible.{u1} R (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toOne.{u1} R _inst_1) r], Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) _inst_2) (MulOneClass.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) _inst_2) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toMul.{u2} S _inst_2) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 _inst_2 _inst_3)) f r)
+  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S _inst_1 _inst_2] (f : F) (r : R) [_inst_4 : Invertible.{u1} R (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toOne.{u1} R _inst_1) r], Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) _inst_2) (MulOneClass.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) _inst_2) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toMul.{u2} S _inst_2) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 _inst_2 _inst_3)) f r)
 Case conversion may be inaccurate. Consider using '#align invertible.map Invertible.mapₓ'. -/
 /-- Monoid homs preserve invertibility. -/
 def Invertible.map {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [MulOneClass S]
@@ -639,7 +639,7 @@ def Invertible.map {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [MulOn
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2)] (f : F) (r : R) [_inst_4 : Invertible.{u1} R (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasOne.{u1} R _inst_1) r] [_inst_5 : Invertible.{u2} S (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toHasOne.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f r)], Eq.{succ u2} S (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f (Invertible.invOf.{u1} R (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasOne.{u1} R _inst_1) r _inst_4)) (Invertible.invOf.{u2} S (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toHasOne.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f r) _inst_5)
 but is expected to have type
-  forall {R : Type.{u3}} {S : Type.{u2}} {F : Type.{u1}} [_inst_1 : MulOneClass.{u3} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2)] (f : F) (r : R) [_inst_4 : Invertible.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r] [_inst_5 : Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) _inst_2) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r)], Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) (Invertible.invOf.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r _inst_4)) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f (Invertible.invOf.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r _inst_4)) (Invertible.invOf.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) _inst_2) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r) _inst_5)
+  forall {R : Type.{u3}} {S : Type.{u2}} {F : Type.{u1}} [_inst_1 : MulOneClass.{u3} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2)] (f : F) (r : R) [_inst_4 : Invertible.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r] [_inst_5 : Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) _inst_2) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r)], Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) (Invertible.invOf.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r _inst_4)) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f (Invertible.invOf.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r _inst_4)) (Invertible.invOf.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) _inst_2) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r) _inst_5)
 Case conversion may be inaccurate. Consider using '#align map_inv_of map_invOfₓ'. -/
 /-- Note that the `invertible (f r)` argument can be satisfied by using `letI := invertible.map f r`
 before applying this lemma. -/
@@ -654,7 +654,7 @@ theorem map_invOf {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [Monoid
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} {G : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u2, u1} G S R _inst_2 _inst_1] (f : R -> S) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (coeFn.{succ u3, max (succ u2) (succ u1)} G (fun (_x : G) => S -> R) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} G S (fun (_x : S) => R) (MulHomClass.toFunLike.{u3, u2, u1} G S R (MulOneClass.toHasMul.{u2} S _inst_2) (MulOneClass.toHasMul.{u1} R _inst_1) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G S R _inst_2 _inst_1 _inst_3))) g) f) -> (forall [_inst_4 : Invertible.{u2} S (MulOneClass.toHasMul.{u2} S _inst_2) (MulOneClass.toHasOne.{u2} S _inst_2) (f r)], Invertible.{u1} R (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasOne.{u1} R _inst_1) r)
 but is expected to have type
-  forall {R : Type.{u1}} {S : Type.{u2}} {G : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u2, u1} G S R _inst_2 _inst_1] (f : R -> S) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (FunLike.coe.{succ u3, succ u2, succ u1} G S (fun (_x : S) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : S) => R) _x) (MulHomClass.toFunLike.{u3, u2, u1} G S R (MulOneClass.toMul.{u2} S _inst_2) (MulOneClass.toMul.{u1} R _inst_1) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G S R _inst_2 _inst_1 _inst_3)) g) f) -> (forall [_inst_4 : Invertible.{u2} S (MulOneClass.toMul.{u2} S _inst_2) (MulOneClass.toOne.{u2} S _inst_2) (f r)], Invertible.{u1} R (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toOne.{u1} R _inst_1) r)
+  forall {R : Type.{u1}} {S : Type.{u2}} {G : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u2, u1} G S R _inst_2 _inst_1] (f : R -> S) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (FunLike.coe.{succ u3, succ u2, succ u1} G S (fun (_x : S) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : S) => R) _x) (MulHomClass.toFunLike.{u3, u2, u1} G S R (MulOneClass.toMul.{u2} S _inst_2) (MulOneClass.toMul.{u1} R _inst_1) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G S R _inst_2 _inst_1 _inst_3)) g) f) -> (forall [_inst_4 : Invertible.{u2} S (MulOneClass.toMul.{u2} S _inst_2) (MulOneClass.toOne.{u2} S _inst_2) (f r)], Invertible.{u1} R (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toOne.{u1} R _inst_1) r)
 Case conversion may be inaccurate. Consider using '#align invertible.of_left_inverse Invertible.ofLeftInverseₓ'. -/
 /-- If a function `f : R → S` has a left-inverse that is a monoid hom,
   then `r : R` is invertible if `f r` is.
@@ -671,7 +671,7 @@ def Invertible.ofLeftInverse {R : Type _} {S : Type _} {G : Type _} [MulOneClass
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : Monoid.{u1} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2)] [_inst_4 : MonoidHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1)] (f : F) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (coeFn.{succ u4, max (succ u2) (succ u1)} G (fun (_x : G) => S -> R) (FunLike.hasCoeToFun.{succ u4, succ u2, succ u1} G S (fun (_x : S) => R) (MulHomClass.toFunLike.{u4, u2, u1} G S R (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MonoidHomClass.toMulHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) _inst_4))) g) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f)) -> (Equiv.{succ u2, succ u1} (Invertible.{u2} S (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toHasOne.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f r)) (Invertible.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toHasOne.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) r))
 but is expected to have type
-  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : Monoid.{u1} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2)] [_inst_4 : MonoidHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1)] (f : F) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (FunLike.coe.{succ u4, succ u2, succ u1} G S (fun (_x : S) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : S) => R) _x) (MulHomClass.toFunLike.{u4, u2, u1} G S R (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MonoidHomClass.toMulHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) _inst_4)) g) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f)) -> (Equiv.{succ u2, succ u1} (Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) _inst_2) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r)) (Invertible.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (Monoid.toOne.{u1} R _inst_1) r))
+  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : Monoid.{u1} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2)] [_inst_4 : MonoidHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1)] (f : F) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (FunLike.coe.{succ u4, succ u2, succ u1} G S (fun (_x : S) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : S) => R) _x) (MulHomClass.toFunLike.{u4, u2, u1} G S R (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MonoidHomClass.toMulHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) _inst_4)) g) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f)) -> (Equiv.{succ u2, succ u1} (Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) r) _inst_2) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r)) (Invertible.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (Monoid.toOne.{u1} R _inst_1) r))
 Case conversion may be inaccurate. Consider using '#align invertible_equiv_of_left_inverse invertibleEquivOfLeftInverseₓ'. -/
 /-- Invertibility on either side of a monoid hom with a left-inverse is equivalent. -/
 @[simps]

bump to nightly-2023-05-08-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/08e1d8d4d989df3a6df86f385e9053ec8a372cc1

63e712c6

Diff

@@ -349,7 +349,7 @@ theorem invOf_neg [Monoid α] [HasDistribNeg α] (a : α) [Invertible a] [Invert
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Ring.{u1} α] [_inst_2 : Invertible.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))))], Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))) (Invertible.invOf.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))))) _inst_2)) (Invertible.invOf.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))))) _inst_2)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Ring.{u1} α] [_inst_2 : Invertible.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))) (NonAssocRing.toOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (NonAssocRing.toNatCast.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))], Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (Ring.toSub.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (NonAssocRing.toOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))) (Invertible.invOf.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))) (NonAssocRing.toOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (NonAssocRing.toNatCast.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) _inst_2)) (Invertible.invOf.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))) (NonAssocRing.toOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (NonAssocRing.toNatCast.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) _inst_2)
+  forall {α : Type.{u1}} [_inst_1 : Ring.{u1} α] [_inst_2 : Invertible.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))) (Semiring.toOne.{u1} α (Ring.toSemiring.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (Semiring.toNatCast.{u1} α (Ring.toSemiring.{u1} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))], Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (Ring.toSub.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Semiring.toOne.{u1} α (Ring.toSemiring.{u1} α _inst_1)))) (Invertible.invOf.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))) (Semiring.toOne.{u1} α (Ring.toSemiring.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (Semiring.toNatCast.{u1} α (Ring.toSemiring.{u1} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) _inst_2)) (Invertible.invOf.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))) (Semiring.toOne.{u1} α (Ring.toSemiring.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (Semiring.toNatCast.{u1} α (Ring.toSemiring.{u1} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) _inst_2)
 Case conversion may be inaccurate. Consider using '#align one_sub_inv_of_two one_sub_invOf_twoₓ'. -/
 @[simp]
 theorem one_sub_invOf_two [Ring α] [Invertible (2 : α)] : 1 - (⅟ 2 : α) = ⅟ 2 :=

bump to nightly-2023-04-25-20

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

56c36841

Diff

@@ -236,7 +236,7 @@ def Units.invertible [Monoid α] (u : αˣ) : Invertible (u : α)
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] (u : Units.{u1} α _inst_1) [_inst_2 : Invertible.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{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)], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{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) _inst_2) ((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) [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (Units.val.{u1} α _inst_1 u)], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (Units.val.{u1} α _inst_1 u) _inst_2) (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) [_inst_2 : Invertible.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (Units.val.{u1} α _inst_1 u)], Eq.{succ u1} α (Invertible.invOf.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (Units.val.{u1} α _inst_1 u) _inst_2) (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 inv_of_units invOf_unitsₓ'. -/
 @[simp]
 theorem invOf_units [Monoid α] (u : αˣ) [Invertible (u : α)] : ⅟ (u : α) = ↑u⁻¹ :=

bump to nightly-2023-03-27-02

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

0e4ebd8c

Diff

@@ -347,7 +347,7 @@ theorem invOf_neg [Monoid α] [HasDistribNeg α] (a : α) [Invertible a] [Invert
 
 /- warning: one_sub_inv_of_two -> one_sub_invOf_two is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Ring.{u1} α] [_inst_2 : Invertible.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))))))], Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))))) (Invertible.invOf.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))))))) _inst_2)) (Invertible.invOf.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))))))) _inst_2)
+  forall {α : Type.{u1}} [_inst_1 : Ring.{u1} α] [_inst_2 : Invertible.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))))], Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))) (Invertible.invOf.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))))) _inst_2)) (Invertible.invOf.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))))) _inst_2)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Ring.{u1} α] [_inst_2 : Invertible.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))) (NonAssocRing.toOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (NonAssocRing.toNatCast.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))], Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (Ring.toSub.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (NonAssocRing.toOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))) (Invertible.invOf.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))) (NonAssocRing.toOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (NonAssocRing.toNatCast.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) _inst_2)) (Invertible.invOf.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))) (NonAssocRing.toOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (NonAssocRing.toNatCast.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) _inst_2)
 Case conversion may be inaccurate. Consider using '#align one_sub_inv_of_two one_sub_invOf_twoₓ'. -/

bump to nightly-2023-03-11-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

a8ee822f

Diff

@@ -624,7 +624,7 @@ end GroupWithZero
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S _inst_1 _inst_2] (f : F) (r : R) [_inst_4 : Invertible.{u1} R (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasOne.{u1} R _inst_1) r], Invertible.{u2} S (MulOneClass.toHasMul.{u2} S _inst_2) (MulOneClass.toHasOne.{u2} S _inst_2) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasMul.{u2} S _inst_2) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 _inst_2 _inst_3))) f r)
 but is expected to have type
-  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S _inst_1 _inst_2] (f : F) (r : R) [_inst_4 : Invertible.{u1} R (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toOne.{u1} R _inst_1) r], Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) _inst_2) (MulOneClass.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) _inst_2) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toMul.{u2} S _inst_2) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 _inst_2 _inst_3)) f r)
+  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S _inst_1 _inst_2] (f : F) (r : R) [_inst_4 : Invertible.{u1} R (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toOne.{u1} R _inst_1) r], Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) _inst_2) (MulOneClass.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) _inst_2) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toMul.{u2} S _inst_2) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 _inst_2 _inst_3)) f r)
 Case conversion may be inaccurate. Consider using '#align invertible.map Invertible.mapₓ'. -/
 /-- Monoid homs preserve invertibility. -/
 def Invertible.map {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [MulOneClass S]
@@ -639,7 +639,7 @@ def Invertible.map {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [MulOn
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2)] (f : F) (r : R) [_inst_4 : Invertible.{u1} R (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasOne.{u1} R _inst_1) r] [_inst_5 : Invertible.{u2} S (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toHasOne.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f r)], Eq.{succ u2} S (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f (Invertible.invOf.{u1} R (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasOne.{u1} R _inst_1) r _inst_4)) (Invertible.invOf.{u2} S (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toHasOne.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f r) _inst_5)
 but is expected to have type
-  forall {R : Type.{u3}} {S : Type.{u2}} {F : Type.{u1}} [_inst_1 : MulOneClass.{u3} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2)] (f : F) (r : R) [_inst_4 : Invertible.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r] [_inst_5 : Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) _inst_2) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r)], Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) (Invertible.invOf.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r _inst_4)) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f (Invertible.invOf.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r _inst_4)) (Invertible.invOf.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) _inst_2) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r) _inst_5)
+  forall {R : Type.{u3}} {S : Type.{u2}} {F : Type.{u1}} [_inst_1 : MulOneClass.{u3} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2)] (f : F) (r : R) [_inst_4 : Invertible.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r] [_inst_5 : Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) _inst_2) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r)], Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) (Invertible.invOf.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r _inst_4)) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f (Invertible.invOf.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r _inst_4)) (Invertible.invOf.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) _inst_2) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r) _inst_5)
 Case conversion may be inaccurate. Consider using '#align map_inv_of map_invOfₓ'. -/
 /-- Note that the `invertible (f r)` argument can be satisfied by using `letI := invertible.map f r`
 before applying this lemma. -/
@@ -654,7 +654,7 @@ theorem map_invOf {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [Monoid
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} {G : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u2, u1} G S R _inst_2 _inst_1] (f : R -> S) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (coeFn.{succ u3, max (succ u2) (succ u1)} G (fun (_x : G) => S -> R) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} G S (fun (_x : S) => R) (MulHomClass.toFunLike.{u3, u2, u1} G S R (MulOneClass.toHasMul.{u2} S _inst_2) (MulOneClass.toHasMul.{u1} R _inst_1) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G S R _inst_2 _inst_1 _inst_3))) g) f) -> (forall [_inst_4 : Invertible.{u2} S (MulOneClass.toHasMul.{u2} S _inst_2) (MulOneClass.toHasOne.{u2} S _inst_2) (f r)], Invertible.{u1} R (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasOne.{u1} R _inst_1) r)
 but is expected to have type
-  forall {R : Type.{u1}} {S : Type.{u2}} {G : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u2, u1} G S R _inst_2 _inst_1] (f : R -> S) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (FunLike.coe.{succ u3, succ u2, succ u1} G S (fun (_x : S) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : S) => R) _x) (MulHomClass.toFunLike.{u3, u2, u1} G S R (MulOneClass.toMul.{u2} S _inst_2) (MulOneClass.toMul.{u1} R _inst_1) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G S R _inst_2 _inst_1 _inst_3)) g) f) -> (forall [_inst_4 : Invertible.{u2} S (MulOneClass.toMul.{u2} S _inst_2) (MulOneClass.toOne.{u2} S _inst_2) (f r)], Invertible.{u1} R (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toOne.{u1} R _inst_1) r)
+  forall {R : Type.{u1}} {S : Type.{u2}} {G : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u2, u1} G S R _inst_2 _inst_1] (f : R -> S) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (FunLike.coe.{succ u3, succ u2, succ u1} G S (fun (_x : S) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : S) => R) _x) (MulHomClass.toFunLike.{u3, u2, u1} G S R (MulOneClass.toMul.{u2} S _inst_2) (MulOneClass.toMul.{u1} R _inst_1) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G S R _inst_2 _inst_1 _inst_3)) g) f) -> (forall [_inst_4 : Invertible.{u2} S (MulOneClass.toMul.{u2} S _inst_2) (MulOneClass.toOne.{u2} S _inst_2) (f r)], Invertible.{u1} R (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toOne.{u1} R _inst_1) r)
 Case conversion may be inaccurate. Consider using '#align invertible.of_left_inverse Invertible.ofLeftInverseₓ'. -/
 /-- If a function `f : R → S` has a left-inverse that is a monoid hom,
   then `r : R` is invertible if `f r` is.
@@ -671,7 +671,7 @@ def Invertible.ofLeftInverse {R : Type _} {S : Type _} {G : Type _} [MulOneClass
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : Monoid.{u1} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2)] [_inst_4 : MonoidHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1)] (f : F) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (coeFn.{succ u4, max (succ u2) (succ u1)} G (fun (_x : G) => S -> R) (FunLike.hasCoeToFun.{succ u4, succ u2, succ u1} G S (fun (_x : S) => R) (MulHomClass.toFunLike.{u4, u2, u1} G S R (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MonoidHomClass.toMulHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) _inst_4))) g) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f)) -> (Equiv.{succ u2, succ u1} (Invertible.{u2} S (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toHasOne.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f r)) (Invertible.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toHasOne.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) r))
 but is expected to have type
-  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : Monoid.{u1} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2)] [_inst_4 : MonoidHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1)] (f : F) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (FunLike.coe.{succ u4, succ u2, succ u1} G S (fun (_x : S) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : S) => R) _x) (MulHomClass.toFunLike.{u4, u2, u1} G S R (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MonoidHomClass.toMulHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) _inst_4)) g) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f)) -> (Equiv.{succ u2, succ u1} (Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) _inst_2) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r)) (Invertible.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (Monoid.toOne.{u1} R _inst_1) r))
+  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : Monoid.{u1} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2)] [_inst_4 : MonoidHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1)] (f : F) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (FunLike.coe.{succ u4, succ u2, succ u1} G S (fun (_x : S) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : S) => R) _x) (MulHomClass.toFunLike.{u4, u2, u1} G S R (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MonoidHomClass.toMulHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) _inst_4)) g) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f)) -> (Equiv.{succ u2, succ u1} (Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) r) _inst_2) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r)) (Invertible.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (Monoid.toOne.{u1} R _inst_1) r))
 Case conversion may be inaccurate. Consider using '#align invertible_equiv_of_left_inverse invertibleEquivOfLeftInverseₓ'. -/
 /-- Invertibility on either side of a monoid hom with a left-inverse is equivalent. -/
 @[simps]

bump to nightly-2023-03-08-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/38f16f960f5006c6c0c2bac7b0aba5273188f4e5

10f15343

Diff

@@ -624,7 +624,7 @@ end GroupWithZero
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S _inst_1 _inst_2] (f : F) (r : R) [_inst_4 : Invertible.{u1} R (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasOne.{u1} R _inst_1) r], Invertible.{u2} S (MulOneClass.toHasMul.{u2} S _inst_2) (MulOneClass.toHasOne.{u2} S _inst_2) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasMul.{u2} S _inst_2) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 _inst_2 _inst_3))) f r)
 but is expected to have type
-  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S _inst_1 _inst_2] (f : F) (r : R) [_inst_4 : Invertible.{u1} R (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toOne.{u1} R _inst_1) r], Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) r) _inst_2) (MulOneClass.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) r) _inst_2) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toMul.{u2} S _inst_2) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 _inst_2 _inst_3)) f r)
+  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S _inst_1 _inst_2] (f : F) (r : R) [_inst_4 : Invertible.{u1} R (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toOne.{u1} R _inst_1) r], Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) _inst_2) (MulOneClass.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) _inst_2) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toMul.{u2} S _inst_2) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 _inst_2 _inst_3)) f r)
 Case conversion may be inaccurate. Consider using '#align invertible.map Invertible.mapₓ'. -/
 /-- Monoid homs preserve invertibility. -/
 def Invertible.map {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [MulOneClass S]
@@ -639,7 +639,7 @@ def Invertible.map {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [MulOn
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2)] (f : F) (r : R) [_inst_4 : Invertible.{u1} R (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasOne.{u1} R _inst_1) r] [_inst_5 : Invertible.{u2} S (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toHasOne.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f r)], Eq.{succ u2} S (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f (Invertible.invOf.{u1} R (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasOne.{u1} R _inst_1) r _inst_4)) (Invertible.invOf.{u2} S (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toHasOne.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f r) _inst_5)
 but is expected to have type
-  forall {R : Type.{u3}} {S : Type.{u2}} {F : Type.{u1}} [_inst_1 : MulOneClass.{u3} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2)] (f : F) (r : R) [_inst_4 : Invertible.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r] [_inst_5 : Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) r) _inst_2) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r)], Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) (Invertible.invOf.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r _inst_4)) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f (Invertible.invOf.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r _inst_4)) (Invertible.invOf.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) r) _inst_2) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r) _inst_5)
+  forall {R : Type.{u3}} {S : Type.{u2}} {F : Type.{u1}} [_inst_1 : MulOneClass.{u3} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2)] (f : F) (r : R) [_inst_4 : Invertible.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r] [_inst_5 : Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) _inst_2) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r)], Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) (Invertible.invOf.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r _inst_4)) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f (Invertible.invOf.{u3} R (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toOne.{u3} R _inst_1) r _inst_4)) (Invertible.invOf.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) _inst_2) (FunLike.coe.{succ u1, succ u3, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) _x) (MulHomClass.toFunLike.{u1, u3, u2} F R S (MulOneClass.toMul.{u3} R _inst_1) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F R S _inst_1 (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r) _inst_5)
 Case conversion may be inaccurate. Consider using '#align map_inv_of map_invOfₓ'. -/
 /-- Note that the `invertible (f r)` argument can be satisfied by using `letI := invertible.map f r`
 before applying this lemma. -/
@@ -654,7 +654,7 @@ theorem map_invOf {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [Monoid
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} {G : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u2, u1} G S R _inst_2 _inst_1] (f : R -> S) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (coeFn.{succ u3, max (succ u2) (succ u1)} G (fun (_x : G) => S -> R) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} G S (fun (_x : S) => R) (MulHomClass.toFunLike.{u3, u2, u1} G S R (MulOneClass.toHasMul.{u2} S _inst_2) (MulOneClass.toHasMul.{u1} R _inst_1) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G S R _inst_2 _inst_1 _inst_3))) g) f) -> (forall [_inst_4 : Invertible.{u2} S (MulOneClass.toHasMul.{u2} S _inst_2) (MulOneClass.toHasOne.{u2} S _inst_2) (f r)], Invertible.{u1} R (MulOneClass.toHasMul.{u1} R _inst_1) (MulOneClass.toHasOne.{u1} R _inst_1) r)
 but is expected to have type
-  forall {R : Type.{u1}} {S : Type.{u2}} {G : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u2, u1} G S R _inst_2 _inst_1] (f : R -> S) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (FunLike.coe.{succ u3, succ u2, succ u1} G S (fun (_x : S) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : S) => R) _x) (MulHomClass.toFunLike.{u3, u2, u1} G S R (MulOneClass.toMul.{u2} S _inst_2) (MulOneClass.toMul.{u1} R _inst_1) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G S R _inst_2 _inst_1 _inst_3)) g) f) -> (forall [_inst_4 : Invertible.{u2} S (MulOneClass.toMul.{u2} S _inst_2) (MulOneClass.toOne.{u2} S _inst_2) (f r)], Invertible.{u1} R (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toOne.{u1} R _inst_1) r)
+  forall {R : Type.{u1}} {S : Type.{u2}} {G : Type.{u3}} [_inst_1 : MulOneClass.{u1} R] [_inst_2 : MulOneClass.{u2} S] [_inst_3 : MonoidHomClass.{u3, u2, u1} G S R _inst_2 _inst_1] (f : R -> S) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (FunLike.coe.{succ u3, succ u2, succ u1} G S (fun (_x : S) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : S) => R) _x) (MulHomClass.toFunLike.{u3, u2, u1} G S R (MulOneClass.toMul.{u2} S _inst_2) (MulOneClass.toMul.{u1} R _inst_1) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G S R _inst_2 _inst_1 _inst_3)) g) f) -> (forall [_inst_4 : Invertible.{u2} S (MulOneClass.toMul.{u2} S _inst_2) (MulOneClass.toOne.{u2} S _inst_2) (f r)], Invertible.{u1} R (MulOneClass.toMul.{u1} R _inst_1) (MulOneClass.toOne.{u1} R _inst_1) r)
 Case conversion may be inaccurate. Consider using '#align invertible.of_left_inverse Invertible.ofLeftInverseₓ'. -/
 /-- If a function `f : R → S` has a left-inverse that is a monoid hom,
   then `r : R` is invertible if `f r` is.
@@ -671,7 +671,7 @@ def Invertible.ofLeftInverse {R : Type _} {S : Type _} {G : Type _} [MulOneClass
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : Monoid.{u1} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2)] [_inst_4 : MonoidHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1)] (f : F) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (coeFn.{succ u4, max (succ u2) (succ u1)} G (fun (_x : G) => S -> R) (FunLike.hasCoeToFun.{succ u4, succ u2, succ u1} G S (fun (_x : S) => R) (MulHomClass.toFunLike.{u4, u2, u1} G S R (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MonoidHomClass.toMulHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) _inst_4))) g) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f)) -> (Equiv.{succ u2, succ u1} (Invertible.{u2} S (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toHasOne.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => R -> S) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F R (fun (_x : R) => S) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toHasMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3))) f r)) (Invertible.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toHasOne.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) r))
 but is expected to have type
-  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : Monoid.{u1} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2)] [_inst_4 : MonoidHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1)] (f : F) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (FunLike.coe.{succ u4, succ u2, succ u1} G S (fun (_x : S) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : S) => R) _x) (MulHomClass.toFunLike.{u4, u2, u1} G S R (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MonoidHomClass.toMulHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) _inst_4)) g) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f)) -> (Equiv.{succ u2, succ u1} (Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) r) _inst_2) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r)) (Invertible.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (Monoid.toOne.{u1} R _inst_1) r))
+  forall {R : Type.{u1}} {S : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : Monoid.{u1} R] [_inst_2 : Monoid.{u2} S] [_inst_3 : MonoidHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2)] [_inst_4 : MonoidHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1)] (f : F) (g : G) (r : R), (Function.LeftInverse.{succ u1, succ u2} R S (FunLike.coe.{succ u4, succ u2, succ u1} G S (fun (_x : S) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : S) => R) _x) (MulHomClass.toFunLike.{u4, u2, u1} G S R (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MonoidHomClass.toMulHomClass.{u4, u2, u1} G S R (Monoid.toMulOneClass.{u2} S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) _inst_4)) g) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f)) -> (Equiv.{succ u2, succ u1} (Invertible.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) _inst_2)) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) r) _inst_2) (FunLike.coe.{succ u3, succ u1, succ u2} F R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => S) _x) (MulHomClass.toFunLike.{u3, u1, u2} F R S (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} S (Monoid.toMulOneClass.{u2} S _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F R S (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} S _inst_2) _inst_3)) f r)) (Invertible.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (Monoid.toOne.{u1} R _inst_1) r))
 Case conversion may be inaccurate. Consider using '#align invertible_equiv_of_left_inverse invertibleEquivOfLeftInverseₓ'. -/
 /-- Invertibility on either side of a monoid hom with a left-inverse is equivalent. -/
 @[simps]

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

chore: refactor to avoid importing Ring for Group topics (#11913)

This is a far from a complete success at the PR title, but it makes a fair bit of progress, and then guards this with appropriate assert_not_exists Ring statements.

It also breaks apart the Mathlib.GroupTheory.Subsemigroup.[Center|Centralizer] files, to pull the Set.center and Set.centralizer declarations into their own files not depending on Subsemigroup.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

8e052acc

chore: refactor to avoid importing Ring for Group topics (#11913)

This is a far from a complete success at the PR title, but it makes a fair bit of progress, and then guards this with appropriate assert_not_exists Ring statements.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

8e052acc

Diff

@@ -9,7 +9,6 @@ import Mathlib.Algebra.Group.Hom.Defs
 import Mathlib.Algebra.Group.Units
 import Mathlib.Algebra.GroupPower.Basic
 import Mathlib.Algebra.GroupWithZero.Units.Basic
-import Mathlib.Algebra.Ring.Defs
 
 #align_import algebra.invertible from "leanprover-community/mathlib"@"722b3b152ddd5e0cf21c0a29787c76596cb6b422"
 /-!
@@ -66,28 +65,6 @@ theorem nonempty_invertible_iff_isUnit [Monoid α] (a : α) : Nonempty (Invertib
   ⟨Nonempty.rec <| @isUnit_of_invertible _ _ _, IsUnit.nonempty_invertible⟩
 #align nonempty_invertible_iff_is_unit nonempty_invertible_iff_isUnit
 
-/-- `-⅟a` is the inverse of `-a` -/
-def invertibleNeg [Mul α] [One α] [HasDistribNeg α] (a : α) [Invertible a] : Invertible (-a) :=
-  ⟨-⅟ a, by simp, by simp⟩
-#align invertible_neg invertibleNeg
-
-@[simp]
-theorem invOf_neg [Monoid α] [HasDistribNeg α] (a : α) [Invertible a] [Invertible (-a)] :
-    ⅟ (-a) = -⅟ a :=
-  invOf_eq_right_inv (by simp)
-#align inv_of_neg invOf_neg
-
-@[simp]
-theorem one_sub_invOf_two [Ring α] [Invertible (2 : α)] : 1 - (⅟ 2 : α) = ⅟ 2 :=
-  (isUnit_of_invertible (2 : α)).mul_right_inj.1 <| by
-    rw [mul_sub, mul_invOf_self, mul_one, ← one_add_one_eq_two, add_sub_cancel_right]
-#align one_sub_inv_of_two one_sub_invOf_two
-
-@[simp]
-theorem invOf_two_add_invOf_two [NonAssocSemiring α] [Invertible (2 : α)] :
-    (⅟ 2 : α) + (⅟ 2 : α) = 1 := by rw [← two_mul, mul_invOf_self]
-#align inv_of_two_add_inv_of_two invOf_two_add_invOf_two
-
 theorem Commute.invOf_right [Monoid α] {a b : α} [Invertible b] (h : Commute a b) :
     Commute a (⅟ b) :=
   calc
@@ -110,9 +87,6 @@ theorem commute_invOf {M : Type*} [One M] [Mul M] (m : M) [Invertible m] : Commu
     _ = ⅟ m * m := (invOf_mul_self m).symm
 #align commute_inv_of commute_invOf
 
-theorem pos_of_invertible_cast [Semiring α] [Nontrivial α] (n : ℕ) [Invertible (n : α)] : 0 < n :=
-  Nat.zero_lt_of_ne_zero fun h => nonzero_of_invertible (n : α) (h ▸ Nat.cast_zero)
-
 section Monoid
 
 variable [Monoid α]

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

@@ -80,7 +80,7 @@ theorem invOf_neg [Monoid α] [HasDistribNeg α] (a : α) [Invertible a] [Invert
 @[simp]
 theorem one_sub_invOf_two [Ring α] [Invertible (2 : α)] : 1 - (⅟ 2 : α) = ⅟ 2 :=
   (isUnit_of_invertible (2 : α)).mul_right_inj.1 <| by
-    rw [mul_sub, mul_invOf_self, mul_one, ← one_add_one_eq_two, add_sub_cancel]
+    rw [mul_sub, mul_invOf_self, mul_one, ← one_add_one_eq_two, add_sub_cancel_right]
 #align one_sub_inv_of_two one_sub_invOf_two
 
 @[simp]
@@ -194,12 +194,12 @@ variable [GroupWithZero α]
 
 @[simp]
 theorem div_mul_cancel_of_invertible (a b : α) [Invertible b] : a / b * b = a :=
-  div_mul_cancel a (nonzero_of_invertible b)
+  div_mul_cancel₀ a (nonzero_of_invertible b)
 #align div_mul_cancel_of_invertible div_mul_cancel_of_invertible
 
 @[simp]
 theorem mul_div_cancel_of_invertible (a b : α) [Invertible b] : a * b / b = a :=
-  mul_div_cancel a (nonzero_of_invertible b)
+  mul_div_cancel_right₀ a (nonzero_of_invertible b)
 #align mul_div_cancel_of_invertible mul_div_cancel_of_invertible
 
 @[simp]

chore: classify "simp can prove" porting notes (#11550)

Classifies by adding issue number #10618 to porting notes claiming "simp can prove it".

5befdcb9

Diff

@@ -212,7 +212,7 @@ def invertibleDiv (a b : α) [Invertible a] [Invertible b] : Invertible (a / b)
   ⟨b / a, by simp [← mul_div_assoc], by simp [← mul_div_assoc]⟩
 #align invertible_div invertibleDiv
 
--- Porting note (#11119): removed `simp` attribute as `simp` can prove it
+-- Porting note (#10618): removed `simp` attribute as `simp` can prove it
 theorem invOf_div (a b : α) [Invertible a] [Invertible b] [Invertible (a / b)] :
     ⅟ (a / b) = b / a :=
   invOf_eq_right_inv (by simp [← mul_div_assoc])

chore: Move GroupWithZero lemmas earlier (#10919)

Move from Algebra.GroupWithZero.Units.Lemmas to Algebra.GroupWithZero.Units.Basic the lemmas that can be moved.

8ff9aa61

Diff

@@ -4,9 +4,11 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anne Baanen
 -/
 import Mathlib.Algebra.Invertible.GroupWithZero
+import Mathlib.Algebra.Group.Commute.Units
+import Mathlib.Algebra.Group.Hom.Defs
 import Mathlib.Algebra.Group.Units
 import Mathlib.Algebra.GroupPower.Basic
-import Mathlib.Algebra.GroupWithZero.Units.Lemmas
+import Mathlib.Algebra.GroupWithZero.Units.Basic
 import Mathlib.Algebra.Ring.Defs
 
 #align_import algebra.invertible from "leanprover-community/mathlib"@"722b3b152ddd5e0cf21c0a29787c76596cb6b422"

chore: remove more autoImplicit (#11336)

... or reduce its scope (the full removal is not as obvious).

59f72a90

Diff

@@ -15,9 +15,6 @@ import Mathlib.Algebra.Ring.Defs
 
 -/
 
-set_option autoImplicit true
-
-
 universe u
 
 variable {α : Type u}

chore: classify @[simp] removed porting notes (#11184)

Classifying by adding issue number #11119 to porting notes claiming anything semantically equivalent to:

"@[simp] removed [...]"
"@[simp] removed [...]"
"removed simp attribute"

28527d30

Diff

@@ -213,7 +213,7 @@ def invertibleDiv (a b : α) [Invertible a] [Invertible b] : Invertible (a / b)
   ⟨b / a, by simp [← mul_div_assoc], by simp [← mul_div_assoc]⟩
 #align invertible_div invertibleDiv
 
--- Porting note: removed `simp` attribute as `simp` can prove it
+-- Porting note (#11119): removed `simp` attribute as `simp` can prove it
 theorem invOf_div (a b : α) [Invertible a] [Invertible b] [Invertible (a / b)] :
     ⅟ (a / b) = b / a :=
   invOf_eq_right_inv (by simp [← mul_div_assoc])

doc: Change old Lean 3 commands to Lean 4 in implementation notes (#10707)

I changed Lean's 3 old "variables" command to Lean's 4 command "variable" in some implementation notes. I might have missed some

Co-authored-by: Omar Mohsen <36500353+OmarMohsenGit@users.noreply.github.com>

0a3cc570

Diff

@@ -40,7 +40,7 @@ users can choose which instances to use at the point of use.
 
 For example, here's how you can use an `Invertible 1` instance:
 ```lean
-variables {α : Type*} [Monoid α]
+variable {α : Type*} [Monoid α]
 
 def something_that_needs_inverses (x : α) [Invertible x] := sorry

refactor(Data/FunLike): use unbundled inheritance from FunLike (#8386)

The FunLike hierarchy is very big and gets scanned through each time we need a coercion (via the CoeFun instance). It looks like unbundled inheritance suits Lean 4 better here. The only class that still extends FunLike is EquivLike, since that has a custom coe_injective' field that is easier to implement. All other classes should take FunLike or EquivLike as a parameter.

Zulip thread

Important changes

Previously, morphism classes would be Type-valued and extend FunLike:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  extends FunLike F A B :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

After this PR, they should be Prop-valued and take FunLike as a parameter:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  [FunLike F A B] : Prop :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

(Note that A B stay marked as outParam even though they are not purely required to be so due to the FunLike parameter already filling them in. This is required to see through type synonyms, which is important in the category theory library. Also, I think keeping them as outParam is slightly faster.)

Similarly, MyEquivClass should take EquivLike as a parameter.

As a result, every mention of [MyHomClass F A B] should become [FunLike F A B] [MyHomClass F A B].

Remaining issues

Slower (failing) search

While overall this gives some great speedups, there are some cases that are noticeably slower. In particular, a failing application of a lemma such as map_mul is more expensive. This is due to suboptimal processing of arguments. For example:

variable [FunLike F M N] [Mul M] [Mul N] (f : F) (x : M) (y : M)

theorem map_mul [MulHomClass F M N] : f (x * y) = f x * f y

example [AddHomClass F A B] : f (x * y) = f x * f y := map_mul f _ _

Before this PR, applying map_mul f gives the goals [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Since M and N are out_params, [MulHomClass F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found.

After this PR, the goals become [FunLike F ?M ?N] [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Now [FunLike F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found, before trying MulHomClass F M N which fails. Since the Mul hierarchy is very big, this can be slow to fail, especially when there is no such Mul instance.

A long-term but harder to achieve solution would be to specify the order in which instance goals get solved. For example, we'd like to change the arguments to map_mul to look like [FunLike F M N] [Mul M] [Mul N] [highPriority <| MulHomClass F M N] because MulHomClass fails or succeeds much faster than the others.

As a consequence, the simpNF linter is much slower since by design it tries and fails to apply many map_ lemmas. The same issue occurs a few times in existing calls to simp [map_mul], where map_mul is tried "too soon" and fails. Thanks to the speedup of leanprover/lean4#2478 the impact is very limited, only in files that already were close to the timeout.

`simp` not firing sometimes

This affects map_smulₛₗ and related definitions. For simp lemmas Lean apparently uses a slightly different mechanism to find instances, so that rw can find every argument to map_smulₛₗ successfully but simp can't: leanprover/lean4#3701.

Missing instances due to unification failing

Especially in the category theory library, we might sometimes have a type A which is also accessible as a synonym (Bundled A hA).1. Instance synthesis doesn't always work if we have f : A →* B but x * y : (Bundled A hA).1 or vice versa. This seems to be mostly fixed by keeping A B as outParams in MulHomClass F A B. (Presumably because Lean will do a definitional check A =?= (Bundled A hA).1 instead of using the syntax in the discrimination tree.)

Workaround for issues

The timeouts can be worked around for now by specifying which map_mul we mean, either as map_mul f for some explicit f, or as e.g. MonoidHomClass.map_mul.

map_smulₛₗ not firing as simp lemma can be worked around by going back to the pre-FunLike situation and making LinearMap.map_smulₛₗ a simp lemma instead of the generic map_smulₛₗ. Writing simp [map_smulₛₗ _] also works.

Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Scott Morrison <scott@tqft.net> Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

c6a73d4f

Diff

@@ -223,7 +223,7 @@ end GroupWithZero
 
 /-- Monoid homs preserve invertibility. -/
 def Invertible.map {R : Type*} {S : Type*} {F : Type*} [MulOneClass R] [MulOneClass S]
-    [MonoidHomClass F R S] (f : F) (r : R) [Invertible r] :
+    [FunLike F R S] [MonoidHomClass F R S] (f : F) (r : R) [Invertible r] :
     Invertible (f r) where
   invOf := f (⅟ r)
   invOf_mul_self := by rw [← map_mul, invOf_mul_self, map_one]
@@ -233,7 +233,8 @@ def Invertible.map {R : Type*} {S : Type*} {F : Type*} [MulOneClass R] [MulOneCl
 /-- Note that the `Invertible (f r)` argument can be satisfied by using `letI := Invertible.map f r`
 before applying this lemma. -/
 theorem map_invOf {R : Type*} {S : Type*} {F : Type*} [MulOneClass R] [Monoid S]
-    [MonoidHomClass F R S] (f : F) (r : R) [Invertible r] [ifr : Invertible (f r)] :
+    [FunLike F R S] [MonoidHomClass F R S] (f : F) (r : R)
+    [Invertible r] [ifr : Invertible (f r)] :
     f (⅟ r) = ⅟ (f r) :=
   have h : ifr = Invertible.map f r := Subsingleton.elim _ _
   by subst h; rfl
@@ -245,8 +246,8 @@ theorem map_invOf {R : Type*} {S : Type*} {F : Type*} [MulOneClass R] [Monoid S]
 The inverse is computed as `g (⅟(f r))` -/
 @[simps! (config := .lemmasOnly)]
 def Invertible.ofLeftInverse {R : Type*} {S : Type*} {G : Type*} [MulOneClass R] [MulOneClass S]
-    [MonoidHomClass G S R] (f : R → S) (g : G) (r : R) (h : Function.LeftInverse g f)
-    [Invertible (f r)] : Invertible r :=
+    [FunLike G S R] [MonoidHomClass G S R] (f : R → S) (g : G) (r : R)
+    (h : Function.LeftInverse g f) [Invertible (f r)] : Invertible r :=
   (Invertible.map g (f r)).copy _ (h r).symm
 #align invertible.of_left_inverse Invertible.ofLeftInverse
 #align invertible.of_left_inverse_inv_of Invertible.ofLeftInverse_invOf
@@ -254,8 +255,8 @@ def Invertible.ofLeftInverse {R : Type*} {S : Type*} {G : Type*} [MulOneClass R]
 /-- Invertibility on either side of a monoid hom with a left-inverse is equivalent. -/
 @[simps]
 def invertibleEquivOfLeftInverse {R : Type*} {S : Type*} {F G : Type*} [Monoid R] [Monoid S]
-    [MonoidHomClass F R S] [MonoidHomClass G S R] (f : F) (g : G) (r : R)
-    (h : Function.LeftInverse g f) :
+    [FunLike F R S] [MonoidHomClass F R S] [FunLike G S R] [MonoidHomClass G S R]
+    (f : F) (g : G) (r : R) (h : Function.LeftInverse g f) :
     Invertible (f r) ≃
       Invertible r where
   toFun _ := Invertible.ofLeftInverse f _ _ h

chore: fix some Lean-3-isms in comments (#10240)

96b716e8

Diff

@@ -45,7 +45,7 @@ variables {α : Type*} [Monoid α]
 def something_that_needs_inverses (x : α) [Invertible x] := sorry
 
 section
-local attribute [instance] invertibleOne
+attribute [local instance] invertibleOne
 def something_one := something_that_needs_inverses 1
 end
 ```

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

@@ -4,7 +4,6 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anne Baanen
 -/
 import Mathlib.Algebra.Group.Defs
-import Mathlib.Logic.Basic
 
 #align_import algebra.invertible from "leanprover-community/mathlib"@"722b3b152ddd5e0cf21c0a29787c76596cb6b422"

chore: refactor of Algebra/Group/Defs to reduce imports (#9606)

We are not that far from the point that Algebra/Group/Defs depends on nothing significant besides simps and to_additive.

This removes from Mathlib.Algebra.Group.Defs the dependencies on

Mathlib.Tactic.Basic (which is a grab-bag of random stuff)
Mathlib.Init.Algebra.Classes (which is ancient and half-baked)
Mathlib.Logic.Function.Basic (not particularly important, but it is barely used in this file)

The goal is to avoid all unnecessary imports to set up the definitions of basic algebraic structures.

We also separate out Mathlib.Tactic.TypeStar and Mathlib.Tactic.Lemma as prerequisites to Mathlib.Tactic.Basic, but which can be imported separately when the rest of Mathlib.Tactic.Basic is not needed.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

45df8238

Diff

@@ -4,6 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anne Baanen
 -/
 import Mathlib.Algebra.Group.Defs
+import Mathlib.Logic.Basic
 
 #align_import algebra.invertible from "leanprover-community/mathlib"@"722b3b152ddd5e0cf21c0a29787c76596cb6b422"

Chore: Move Units lemmas earlier (#9461)

Part of #9411

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

7522333a

Diff

@@ -5,6 +5,7 @@ Authors: Anne Baanen
 -/
 import Mathlib.Algebra.Invertible.GroupWithZero
 import Mathlib.Algebra.Group.Units
+import Mathlib.Algebra.GroupPower.Basic
 import Mathlib.Algebra.GroupWithZero.Units.Lemmas
 import Mathlib.Algebra.Ring.Defs
 
@@ -159,6 +160,21 @@ def Invertible.mulRight (a : α) {b : α} (_ : Invertible b) : Invertible a ≃
 #align invertible.mul_right_apply Invertible.mulRight_apply
 #align invertible.mul_right_symm_apply Invertible.mulRight_symm_apply
 
+instance invertiblePow (m : α) [Invertible m] (n : ℕ) : Invertible (m ^ n) where
+  invOf := ⅟ m ^ n
+  invOf_mul_self := by rw [← (commute_invOf m).symm.mul_pow, invOf_mul_self, one_pow]
+  mul_invOf_self := by rw [← (commute_invOf m).mul_pow, mul_invOf_self, one_pow]
+#align invertible_pow invertiblePow
+
+lemma invOf_pow (m : α) [Invertible m] (n : ℕ) [Invertible (m ^ n)] : ⅟ (m ^ n) = ⅟ m ^ n :=
+  @invertible_unique _ _ _ _ _ (invertiblePow m n) rfl
+#align inv_of_pow invOf_pow
+
+/-- If `x ^ n = 1` then `x` has an inverse, `x^(n - 1)`. -/
+def invertibleOfPowEqOne (x : α) (n : ℕ) (hx : x ^ n = 1) (hn : n ≠ 0) : Invertible x :=
+  (Units.ofPowEqOne x n hx hn).invertible
+#align invertible_of_pow_eq_one invertibleOfPowEqOne
+
 end Monoid
 
 section MonoidWithZero

chore(Algebra/Invertible/Defs): extract a variable command (#8441)

As requested by @YaelDillies

26fbe28d

Diff

@@ -238,27 +238,27 @@ def Invertible.mul [Monoid α] {a b : α} (_ : Invertible a) (_ : Invertible b)
   invertibleMul _ _
 #align invertible.mul Invertible.mul
 
-theorem mul_right_inj_of_invertible [Monoid α] {a b : α} (c : α) [Invertible c] :
-    a * c = b * c ↔ a = b :=
+section
+variable [Monoid α] {a b c : α} [Invertible c]
+
+variable (c) in
+theorem mul_right_inj_of_invertible : a * c = b * c ↔ a = b :=
   ⟨fun h => by simpa using congr_arg (· * ⅟c) h, congr_arg (· * _)⟩
 
-theorem mul_left_inj_of_invertible [Monoid α] {a b : α} (c : α) [Invertible c] :
-    c * a = c * b ↔ a = b :=
+variable (c) in
+theorem mul_left_inj_of_invertible : c * a = c * b ↔ a = b :=
   ⟨fun h => by simpa using congr_arg (⅟c * ·) h, congr_arg (_ * ·)⟩
 
-theorem invOf_mul_eq_iff_eq_mul_left [Monoid α] {a b c : α} [Invertible (c : α)] :
-    ⅟c * a = b ↔ a = c * b := by
+theorem invOf_mul_eq_iff_eq_mul_left : ⅟c * a = b ↔ a = c * b := by
   rw [← mul_left_inj_of_invertible (c := c), mul_invOf_self_assoc]
 
-theorem mul_left_eq_iff_eq_invOf_mul [Monoid α] {a b c : α} [Invertible (c : α)] :
-    c * a = b ↔ a = ⅟c * b := by
+theorem mul_left_eq_iff_eq_invOf_mul : c * a = b ↔ a = ⅟c * b := by
   rw [← mul_left_inj_of_invertible (c := ⅟c), invOf_mul_self_assoc]
 
-
-theorem mul_invOf_eq_iff_eq_mul_right [Monoid α] {a b c : α} [Invertible (c : α)] :
-    a * ⅟c = b ↔ a = b * c := by
+theorem mul_invOf_eq_iff_eq_mul_right : a * ⅟c = b ↔ a = b * c := by
   rw [← mul_right_inj_of_invertible (c := c), mul_invOf_mul_self_cancel]
 
-theorem mul_right_eq_iff_eq_mul_invOf [Monoid α] {a b c : α} [Invertible (c : α)] :
-    a * c = b ↔ a = b * ⅟c := by
+theorem mul_right_eq_iff_eq_mul_invOf : a * c = b ↔ a = b * ⅟c := by
   rw [← mul_right_inj_of_invertible (c := ⅟c), mul_mul_invOf_self_cancel]
+
+end

style: cleanup some autoImplicits (#8288)

In some cases adding the arguments manually results in a more obvious argument order anyway

48237d43

Diff

@@ -13,8 +13,6 @@ import Mathlib.Algebra.GroupWithZero.NeZero
 We intentionally keep imports minimal here as this file is used by `Mathlib.Tactic.NormNum`.
 -/
 
-set_option autoImplicit true
-
 universe u
 
 variable {α : Type u}

style: cleanup some autoImplicits (#8288)

In some cases adding the arguments manually results in a more obvious argument order anyway

48237d43

Diff

@@ -75,9 +75,6 @@ invertible, inverse element, invOf, a half, one half, a third, one third, ½, 
 
 -/
 
-set_option autoImplicit true
-
-
 universe u
 
 variable {α : Type u}
@@ -241,26 +238,27 @@ def Invertible.mul [Monoid α] {a b : α} (_ : Invertible a) (_ : Invertible b)
   invertibleMul _ _
 #align invertible.mul Invertible.mul
 
-theorem mul_right_inj_of_invertible [Monoid α] (c : α) [Invertible c] :
+theorem mul_right_inj_of_invertible [Monoid α] {a b : α} (c : α) [Invertible c] :
     a * c = b * c ↔ a = b :=
   ⟨fun h => by simpa using congr_arg (· * ⅟c) h, congr_arg (· * _)⟩
 
-theorem mul_left_inj_of_invertible [Monoid α] (c : α) [Invertible c] :
+theorem mul_left_inj_of_invertible [Monoid α] {a b : α} (c : α) [Invertible c] :
     c * a = c * b ↔ a = b :=
   ⟨fun h => by simpa using congr_arg (⅟c * ·) h, congr_arg (_ * ·)⟩
 
-theorem invOf_mul_eq_iff_eq_mul_left [Monoid α] [Invertible (c : α)] :
+theorem invOf_mul_eq_iff_eq_mul_left [Monoid α] {a b c : α} [Invertible (c : α)] :
     ⅟c * a = b ↔ a = c * b := by
   rw [← mul_left_inj_of_invertible (c := c), mul_invOf_self_assoc]
 
-theorem mul_left_eq_iff_eq_invOf_mul [Monoid α] [Invertible (c : α)] :
+theorem mul_left_eq_iff_eq_invOf_mul [Monoid α] {a b c : α} [Invertible (c : α)] :
     c * a = b ↔ a = ⅟c * b := by
   rw [← mul_left_inj_of_invertible (c := ⅟c), invOf_mul_self_assoc]
 
-theorem mul_invOf_eq_iff_eq_mul_right [Monoid α] [Invertible (c : α)] :
+
+theorem mul_invOf_eq_iff_eq_mul_right [Monoid α] {a b c : α} [Invertible (c : α)] :
     a * ⅟c = b ↔ a = b * c := by
   rw [← mul_right_inj_of_invertible (c := c), mul_invOf_mul_self_cancel]
 
-theorem mul_right_eq_iff_eq_mul_invOf [Monoid α] [Invertible (c : α)] :
+theorem mul_right_eq_iff_eq_mul_invOf [Monoid α] {a b c : α} [Invertible (c : α)] :
     a * c = b ↔ a = b * ⅟c := by
   rw [← mul_right_inj_of_invertible (c := ⅟c), mul_mul_invOf_self_cancel]

chore: only four spaces for subsequent lines (#7286)

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

0c7d6fa5

Diff

@@ -168,7 +168,7 @@ instance Invertible.subsingleton [Monoid α] (a : α) : Subsingleton (Invertible
 /-- If `a` is invertible and `a = b`, then `⅟a = ⅟b`. -/
 @[congr]
 theorem Invertible.congr [Monoid α] (a b : α) [Invertible a] [Invertible b] (h : a = b) :
-  ⅟a = ⅟b := by subst h; congr; apply Subsingleton.allEq
+    ⅟a = ⅟b := by subst h; congr; apply Subsingleton.allEq
 
 /-- If `r` is invertible and `s = r` and `si = ⅟r`, then `s` is invertible with `⅟s = si`. -/
 def Invertible.copy' [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (si : α) (hs : s = r)

chore: split Mathlib.Algebra.Invertible (#6973)

Mathlib.Algebra.Invertible is used by fundamental tactics, and this essentially splits it into the part used by NormNum, and everything else.

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

d67f31e1

chore: split Mathlib.Algebra.Invertible (#6973)

Mathlib.Algebra.Invertible is used by fundamental tactics, and this essentially splits it into the part used by NormNum, and everything else.

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

d67f31e1

chore: split Mathlib.Algebra.Invertible (#6973)

Mathlib.Algebra.Invertible is used by fundamental tactics, and this essentially splits it into the part used by NormNum, and everything else.

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

d67f31e1

fix: simps config for Units (#6514)

552f9b55

Diff

@@ -188,14 +188,14 @@ theorem Invertible.congr [Ring α] (a b : α) [Invertible a] [Invertible b] (h :
 
 /-- An `Invertible` element is a unit. -/
 @[simps]
-def unitOfInvertible [Monoid α] (a : α) [Invertible a] :
-    αˣ where
+def unitOfInvertible [Monoid α] (a : α) [Invertible a] : αˣ where
   val := a
   inv := ⅟ a
   val_inv := by simp
   inv_val := by simp
 #align unit_of_invertible unitOfInvertible
-#align coe_unit_of_invertible unitOfInvertible_val
+#align coe_unit_of_invertible val_unitOfInvertible
+#align coe_inv_unit_of_invertible val_inv_unitOfInvertible
 
 theorem isUnit_of_invertible [Monoid α] (a : α) [Invertible a] : IsUnit a :=
   ⟨unitOfInvertible a, rfl⟩
@@ -377,8 +377,7 @@ variable [Monoid α]
 
 /-- This is the `Invertible` version of `Units.isUnit_units_mul` -/
 @[reducible]
-def invertibleOfInvertibleMul (a b : α) [Invertible a] [Invertible (a * b)] : Invertible b
-    where
+def invertibleOfInvertibleMul (a b : α) [Invertible a] [Invertible (a * b)] : Invertible b where
   invOf := ⅟ (a * b) * a
   invOf_mul_self := by rw [mul_assoc, invOf_mul_self]
   mul_invOf_self := by
@@ -388,8 +387,7 @@ def invertibleOfInvertibleMul (a b : α) [Invertible a] [Invertible (a * b)] : I
 
 /-- This is the `Invertible` version of `Units.isUnit_mul_units` -/
 @[reducible]
-def invertibleOfMulInvertible (a b : α) [Invertible (a * b)] [Invertible b] : Invertible a
-    where
+def invertibleOfMulInvertible (a b : α) [Invertible (a * b)] [Invertible b] : Invertible a where
   invOf := b * ⅟ (a * b)
   invOf_mul_self := by
     rw [← (isUnit_of_invertible b).mul_left_inj, mul_assoc, mul_assoc, invOf_mul_self, mul_one,
@@ -398,24 +396,26 @@ def invertibleOfMulInvertible (a b : α) [Invertible (a * b)] [Invertible b] : I
 #align invertible_of_mul_invertible invertibleOfMulInvertible
 
 /-- `invertibleOfInvertibleMul` and `invertibleMul` as an equivalence. -/
-@[simps]
-def Invertible.mulLeft {a : α} (_ : Invertible a) (b : α) : Invertible b ≃ Invertible (a * b)
-    where
+@[simps apply symm_apply]
+def Invertible.mulLeft {a : α} (_ : Invertible a) (b : α) : Invertible b ≃ Invertible (a * b) where
   toFun _ := invertibleMul a b
   invFun _ := invertibleOfInvertibleMul a _
   left_inv _ := Subsingleton.elim _ _
   right_inv _ := Subsingleton.elim _ _
 #align invertible.mul_left Invertible.mulLeft
+#align invertible.mul_left_apply Invertible.mulLeft_apply
+#align invertible.mul_left_symm_apply Invertible.mulLeft_symm_apply
 
 /-- `invertibleOfMulInvertible` and `invertibleMul` as an equivalence. -/
-@[simps]
-def Invertible.mulRight (a : α) {b : α} (_ : Invertible b) : Invertible a ≃ Invertible (a * b)
-    where
+@[simps apply symm_apply]
+def Invertible.mulRight (a : α) {b : α} (_ : Invertible b) : Invertible a ≃ Invertible (a * b) where
   toFun _ := invertibleMul a b
   invFun _ := invertibleOfMulInvertible _ b
   left_inv _ := Subsingleton.elim _ _
   right_inv _ := Subsingleton.elim _ _
 #align invertible.mul_right Invertible.mulRight
+#align invertible.mul_right_apply Invertible.mulRight_apply
+#align invertible.mul_right_symm_apply Invertible.mulRight_symm_apply
 
 end Monoid

fix: disable autoImplicit globally (#6528)

Autoimplicits are highly controversial and also defeat the performance-improving work in #6474.

The intent of this PR is to make autoImplicit opt-in on a per-file basis, by disabling it in the lakefile and enabling it again with set_option autoImplicit true in the few files that rely on it.

That also keeps this PR small, as opposed to attempting to "fix" files to not need it any more.

I claim that many of the uses of autoImplicit in these files are accidental; situations such as:

Assuming variables are in scope, but pasting the lemma in the wrong section
Pasting in a lemma from a scratch file without checking to see if the variable names are consistent with the rest of the file
Making a copy-paste error between lemmas and forgetting to add an explicit arguments.

Having set_option autoImplicit false as the default prevents these types of mistake being made in the 90% of files where autoImplicits are not used at all, and causes them to be caught by CI during review.

I think there were various points during the port where we encouraged porters to delete the universes u v lines; I think having autoparams for universe variables only would cover a lot of the cases we actually use them, while avoiding any real shortcomings.

A Zulip poll (after combining overlapping votes accordingly) was in favor of this change with 5:5:18 as the no:dontcare:yes vote ratio.

While this PR was being reviewed, a handful of files gained some more likely-accidental autoImplicits. In these places, set_option autoImplicit true has been placed locally within a section, rather than at the top of the file.

0c24f831

Diff

@@ -76,6 +76,8 @@ invertible, inverse element, invOf, a half, one half, a third, one third, ½, 
 
 -/
 
+set_option autoImplicit true
+
 
 universe u

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

@@ -41,7 +41,7 @@ users can choose which instances to use at the point of use.
 
 For example, here's how you can use an `Invertible 1` instance:
 ```lean
-variables {α : Type _} [Monoid α]
+variables {α : Type*} [Monoid α]
 
 def something_that_needs_inverses (x : α) [Invertible x] := sorry
 
@@ -347,7 +347,7 @@ theorem Commute.invOf_left [Monoid α] {a b : α} [Invertible b] (h : Commute b
     _ = a * ⅟ b := by simp [mul_assoc]
 #align commute.inv_of_left Commute.invOf_left
 
-theorem commute_invOf {M : Type _} [One M] [Mul M] (m : M) [Invertible m] : Commute m (⅟ m) :=
+theorem commute_invOf {M : Type*} [One M] [Mul M] (m : M) [Invertible m] : Commute m (⅟ m) :=
   calc
     m * ⅟ m = 1 := mul_invOf_self m
     _ = ⅟ m * m := (invOf_mul_self m).symm
@@ -487,7 +487,7 @@ def invertibleInv {a : α} [Invertible a] : Invertible a⁻¹ :=
 end GroupWithZero
 
 /-- Monoid homs preserve invertibility. -/
-def Invertible.map {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [MulOneClass S]
+def Invertible.map {R : Type*} {S : Type*} {F : Type*} [MulOneClass R] [MulOneClass S]
     [MonoidHomClass F R S] (f : F) (r : R) [Invertible r] :
     Invertible (f r) where
   invOf := f (⅟ r)
@@ -497,7 +497,7 @@ def Invertible.map {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [MulOn
 
 /-- Note that the `Invertible (f r)` argument can be satisfied by using `letI := Invertible.map f r`
 before applying this lemma. -/
-theorem map_invOf {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [Monoid S]
+theorem map_invOf {R : Type*} {S : Type*} {F : Type*} [MulOneClass R] [Monoid S]
     [MonoidHomClass F R S] (f : F) (r : R) [Invertible r] [ifr : Invertible (f r)] :
     f (⅟ r) = ⅟ (f r) :=
   have h : ifr = Invertible.map f r := Subsingleton.elim _ _
@@ -509,7 +509,7 @@ theorem map_invOf {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [Monoid
 
 The inverse is computed as `g (⅟(f r))` -/
 @[simps! (config := .lemmasOnly)]
-def Invertible.ofLeftInverse {R : Type _} {S : Type _} {G : Type _} [MulOneClass R] [MulOneClass S]
+def Invertible.ofLeftInverse {R : Type*} {S : Type*} {G : Type*} [MulOneClass R] [MulOneClass S]
     [MonoidHomClass G S R] (f : R → S) (g : G) (r : R) (h : Function.LeftInverse g f)
     [Invertible (f r)] : Invertible r :=
   (Invertible.map g (f r)).copy _ (h r).symm
@@ -518,7 +518,7 @@ def Invertible.ofLeftInverse {R : Type _} {S : Type _} {G : Type _} [MulOneClass
 
 /-- Invertibility on either side of a monoid hom with a left-inverse is equivalent. -/
 @[simps]
-def invertibleEquivOfLeftInverse {R : Type _} {S : Type _} {F G : Type _} [Monoid R] [Monoid S]
+def invertibleEquivOfLeftInverse {R : Type*} {S : Type*} {F G : Type*} [Monoid R] [Monoid S]
     [MonoidHomClass F R S] [MonoidHomClass G S R] (f : F) (g : G) (r : R)
     (h : Function.LeftInverse g f) :
     Invertible (f r) ≃

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,15 +2,12 @@
 Copyright (c) 2020 Anne Baanen. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anne Baanen
-
-! This file was ported from Lean 3 source module algebra.invertible
-! leanprover-community/mathlib commit 722b3b152ddd5e0cf21c0a29787c76596cb6b422
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Group.Units
 import Mathlib.Algebra.GroupWithZero.Units.Lemmas
 import Mathlib.Algebra.Ring.Defs
+
+#align_import algebra.invertible from "leanprover-community/mathlib"@"722b3b152ddd5e0cf21c0a29787c76596cb6b422"
 /-!
 # Invertible elements

chore: remove occurrences of semicolon after space (#5713)

This is the second half of the changes originally in #5699, removing all occurrences of ; after a space and implementing a linter rule to enforce it.

In most cases this 2-character substring has a space after it, so the following command was run first:

find . -type f -name "*.lean" -exec sed -i -E 's/ ; /; /g' {} \;

The remaining cases were few enough in number that they were done manually.

c795bd35

Diff

@@ -504,7 +504,7 @@ theorem map_invOf {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [Monoid
     [MonoidHomClass F R S] (f : F) (r : R) [Invertible r] [ifr : Invertible (f r)] :
     f (⅟ r) = ⅟ (f r) :=
   have h : ifr = Invertible.map f r := Subsingleton.elim _ _
-  by subst h ; rfl
+  by subst h; rfl
 #align map_inv_of map_invOf
 
 /-- If a function `f : R → S` has a left-inverse that is a monoid hom,

chore: forward-port mathlib#19204 (#5369)

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

8c343e58

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anne Baanen
 
 ! This file was ported from Lean 3 source module algebra.invertible
-! leanprover-community/mathlib commit 10b4e499f43088dd3bb7b5796184ad5216648ab1
+! leanprover-community/mathlib commit 722b3b152ddd5e0cf21c0a29787c76596cb6b422
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -167,12 +167,19 @@ instance Invertible.subsingleton [Monoid α] (a : α) : Subsingleton (Invertible
     exact left_inv_eq_right_inv hba hac⟩
 #align invertible.subsingleton Invertible.subsingleton
 
+/-- If `r` is invertible and `s = r` and `si = ⅟r`, then `s` is invertible with `⅟s = si`. -/
+def Invertible.copy' [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (si : α) (hs : s = r)
+    (hsi : si = ⅟ r) : Invertible s where
+  invOf := si
+  invOf_mul_self := by rw [hs, hsi, invOf_mul_self]
+  mul_invOf_self := by rw [hs, hsi, mul_invOf_self]
+#align invertible.copy' Invertible.copy'
+
 /-- If `r` is invertible and `s = r`, then `s` is invertible. -/
+@[reducible]
 def Invertible.copy [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (hs : s = r) :
-    Invertible s where
-  invOf := ⅟ r
-  invOf_mul_self := by rw [hs, invOf_mul_self]
-  mul_invOf_self := by rw [hs, mul_invOf_self]
+    Invertible s :=
+  hr.copy' _ _ hs rfl
 #align invertible.copy Invertible.copy
 
 /-- If `a` is invertible and `a = b`, then `⅟a = ⅟b`. -/
@@ -296,6 +303,13 @@ theorem invOf_mul [Monoid α] (a b : α) [Invertible a] [Invertible b] [Invertib
   invOf_eq_right_inv (by simp [← mul_assoc])
 #align inv_of_mul invOf_mul
 
+/-- A copy of `invertibleMul` for dot notation. -/
+@[reducible]
+def Invertible.mul [Monoid α] {a b : α} (_ : Invertible a) (_ : Invertible b) :
+    Invertible (a * b) :=
+  invertibleMul _ _
+#align invertible.mul Invertible.mul
+
 theorem mul_right_inj_of_invertible [Monoid α] (c : α) [Invertible c] :
     a * c = b * c ↔ a = b :=
   ⟨fun h => by simpa using congr_arg (· * ⅟c) h, congr_arg (· * _)⟩
@@ -358,6 +372,54 @@ instance (priority := 100) Invertible.ne_zero [MulZeroOneClass α] [Nontrivial 
   ⟨nonzero_of_invertible a⟩
 #align invertible.ne_zero Invertible.ne_zero
 
+section Monoid
+
+variable [Monoid α]
+
+/-- This is the `Invertible` version of `Units.isUnit_units_mul` -/
+@[reducible]
+def invertibleOfInvertibleMul (a b : α) [Invertible a] [Invertible (a * b)] : Invertible b
+    where
+  invOf := ⅟ (a * b) * a
+  invOf_mul_self := by rw [mul_assoc, invOf_mul_self]
+  mul_invOf_self := by
+    rw [← (isUnit_of_invertible a).mul_right_inj, ← mul_assoc, ← mul_assoc, mul_invOf_self, mul_one,
+      one_mul]
+#align invertible_of_invertible_mul invertibleOfInvertibleMul
+
+/-- This is the `Invertible` version of `Units.isUnit_mul_units` -/
+@[reducible]
+def invertibleOfMulInvertible (a b : α) [Invertible (a * b)] [Invertible b] : Invertible a
+    where
+  invOf := b * ⅟ (a * b)
+  invOf_mul_self := by
+    rw [← (isUnit_of_invertible b).mul_left_inj, mul_assoc, mul_assoc, invOf_mul_self, mul_one,
+      one_mul]
+  mul_invOf_self := by rw [← mul_assoc, mul_invOf_self]
+#align invertible_of_mul_invertible invertibleOfMulInvertible
+
+/-- `invertibleOfInvertibleMul` and `invertibleMul` as an equivalence. -/
+@[simps]
+def Invertible.mulLeft {a : α} (_ : Invertible a) (b : α) : Invertible b ≃ Invertible (a * b)
+    where
+  toFun _ := invertibleMul a b
+  invFun _ := invertibleOfInvertibleMul a _
+  left_inv _ := Subsingleton.elim _ _
+  right_inv _ := Subsingleton.elim _ _
+#align invertible.mul_left Invertible.mulLeft
+
+/-- `invertibleOfMulInvertible` and `invertibleMul` as an equivalence. -/
+@[simps]
+def Invertible.mulRight (a : α) {b : α} (_ : Invertible b) : Invertible a ≃ Invertible (a * b)
+    where
+  toFun _ := invertibleMul a b
+  invFun _ := invertibleOfMulInvertible _ b
+  left_inv _ := Subsingleton.elim _ _
+  right_inv _ := Subsingleton.elim _ _
+#align invertible.mul_right Invertible.mulRight
+
+end Monoid
+
 section MonoidWithZero
 
 variable [MonoidWithZero α]

feat: port Algebra.Lie.Classical (#4788)

468830c8

Diff

@@ -189,6 +189,7 @@ def unitOfInvertible [Monoid α] (a : α) [Invertible a] :
   val_inv := by simp
   inv_val := by simp
 #align unit_of_invertible unitOfInvertible
+#align coe_unit_of_invertible unitOfInvertible_val
 
 theorem isUnit_of_invertible [Monoid α] (a : α) [Invertible a] : IsUnit a :=
   ⟨unitOfInvertible a, rfl⟩

chore: fix typos (#4518)

I ran codespell Mathlib and got tired halfway through the suggestions.

92beef58

Diff

@@ -413,7 +413,7 @@ def invertibleDiv (a b : α) [Invertible a] [Invertible b] : Invertible (a / b)
   ⟨b / a, by simp [← mul_div_assoc], by simp [← mul_div_assoc]⟩
 #align invertible_div invertibleDiv
 
--- Porting note: removed `simp` attibute as `simp` can prove it
+-- Porting note: removed `simp` attribute as `simp` can prove it
 theorem invOf_div (a b : α) [Invertible a] [Invertible b] [Invertible (a / b)] :
     ⅟ (a / b) = b / a :=
   invOf_eq_right_inv (by simp [← mul_div_assoc])

chore: fix upper/lowercase in comments (#4360)

Run a non-interactive version of fix-comments.py on all files.
Go through the diff and manually add/discard/edit chunks.

27d257fc

Diff

@@ -44,7 +44,7 @@ users can choose which instances to use at the point of use.
 
 For example, here's how you can use an `Invertible 1` instance:
 ```lean
-variables {α : Type _} [monoid α]
+variables {α : Type _} [Monoid α]
 
 def something_that_needs_inverses (x : α) [Invertible x] := sorry
 
@@ -180,7 +180,7 @@ def Invertible.copy [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (hs :
 theorem Invertible.congr [Ring α] (a b : α) [Invertible a] [Invertible b] (h : a = b) :
   ⅟a = ⅟b := by subst h; congr; apply Subsingleton.allEq
 
-/-- An `invertible` element is a unit. -/
+/-- An `Invertible` element is a unit. -/
 @[simps]
 def unitOfInvertible [Monoid α] (a : α) [Invertible a] :
     αˣ where
@@ -435,7 +435,7 @@ def Invertible.map {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [MulOn
   mul_invOf_self := by rw [← map_mul, mul_invOf_self, map_one]
 #align invertible.map Invertible.map
 
-/-- Note that the `invertible (f r)` argument can be satisfied by using `letI := invertible.map f r`
+/-- Note that the `Invertible (f r)` argument can be satisfied by using `letI := Invertible.map f r`
 before applying this lemma. -/
 theorem map_invOf {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [Monoid S]
     [MonoidHomClass F R S] (f : F) (r : R) [Invertible r] [ifr : Invertible (f r)] :

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

d8af7b4f

Diff

@@ -161,10 +161,11 @@ theorem invertible_unique {α : Type u} [Monoid α] (a b : α) [Invertible a] [I
   rw [h, mul_invOf_self]
 #align invertible_unique invertible_unique
 
-instance [Monoid α] (a : α) : Subsingleton (Invertible a) :=
+instance Invertible.subsingleton [Monoid α] (a : α) : Subsingleton (Invertible a) :=
   ⟨fun ⟨b, hba, hab⟩ ⟨c, _, hac⟩ => by
     congr
     exact left_inv_eq_right_inv hba hac⟩
+#align invertible.subsingleton Invertible.subsingleton
 
 /-- If `r` is invertible and `s = r`, then `s` is invertible. -/
 def Invertible.copy [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (hs : s = r) :

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

@@ -324,7 +324,6 @@ theorem Commute.invOf_right [Monoid α] {a b : α} [Invertible b] (h : Commute a
     a * ⅟ b = ⅟ b * (b * a * ⅟ b) := by simp [mul_assoc]
     _ = ⅟ b * (a * b * ⅟ b) := by rw [h.eq]
     _ = ⅟ b * a := by simp [mul_assoc]
-
 #align commute.inv_of_right Commute.invOf_right
 
 theorem Commute.invOf_left [Monoid α] {a b : α} [Invertible b] (h : Commute b a) :
@@ -333,14 +332,12 @@ theorem Commute.invOf_left [Monoid α] {a b : α} [Invertible b] (h : Commute b
     ⅟ b * a = ⅟ b * (a * b * ⅟ b) := by simp [mul_assoc]
     _ = ⅟ b * (b * a * ⅟ b) := by rw [h.eq]
     _ = a * ⅟ b := by simp [mul_assoc]
-
 #align commute.inv_of_left Commute.invOf_left
 
 theorem commute_invOf {M : Type _} [One M] [Mul M] (m : M) [Invertible m] : Commute m (⅟ m) :=
   calc
     m * ⅟ m = 1 := mul_invOf_self m
     _ = ⅟ m * m := (invOf_mul_self m).symm
-
 #align commute_inv_of commute_invOf
 
 theorem nonzero_of_invertible [MulZeroOneClass α] (a : α) [Nontrivial α] [Invertible a] : a ≠ 0 :=
@@ -349,7 +346,6 @@ theorem nonzero_of_invertible [MulZeroOneClass α] (a : α) [Nontrivial α] [Inv
     calc
       0 = ⅟ a * a := by simp [ha]
       _ = 1 := invOf_mul_self a
-
 #align nonzero_of_invertible nonzero_of_invertible
 
 theorem pos_of_invertible_cast [Semiring α] [Nontrivial α] (n : ℕ) [Invertible (n : α)] : 0 < n :=
@@ -445,7 +441,6 @@ theorem map_invOf {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [Monoid
     f (⅟ r) = ⅟ (f r) :=
   have h : ifr = Invertible.map f r := Subsingleton.elim _ _
   by subst h ; rfl
-
 #align map_inv_of map_invOf
 
 /-- If a function `f : R → S` has a left-inverse that is a monoid hom,

feat: recognize scientific notation in norm_num (#1707)

We implement #1706.

In addition to a norm_num extension for OfScientific.ofScientific, we implement extensions for

Int.ofNat
mkRat
Rat.cast/RatCast.ratCast

which made implementation more convenient. We also patch up the other two *.cast evaluators consistently while we're at it.

We create an instance of OfScientific K for any division ring K.

See Zulip discussion here for the original discussion, and this Zulip discussion for the more recent one.

bc67aad9

Diff

@@ -54,6 +54,25 @@ def something_one := something_that_needs_inverses 1
 end
 ```
 
+### Typeclass search vs. unification for `simp` lemmas
+
+Note that since typeclass search searches the local context first, an instance argument like
+`[Invertible a]` might sometimes be filled by a different term than the one we'd find by
+unification (i.e., the one that's used as an implicit argument to `⅟`).
+
+This can cause issues with `simp`. Therefore, some lemmas are duplicated, with the `@[simp]`
+versions using unification and the user-facing ones using typeclass search.
+
+Since unification can make backwards rewriting (e.g. `rw [← mylemma]`) impractical, we still want
+the instance-argument versions; therefore the user-facing versions retain the instance arguments
+and the original lemma name, whereas the `@[simp]`/unification ones acquire a `'` at the end of
+their name.
+
+We modify this file according to the above pattern only as needed; therefore, most `@[simp]` lemmas
+here are not part of such a duplicate pair. This is not (yet) intended as a permanent solution.
+
+See Zulip: [https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Invertible.201.20simps/near/320558233]
+
 ## Tags
 
 invertible, inverse element, invOf, a half, one half, a third, one third, ½, ⅓
@@ -81,31 +100,49 @@ prefix:max
   Invertible.invOf
 
 @[simp]
+theorem invOf_mul_self' [Mul α] [One α] (a : α) {_ : Invertible a} : ⅟ a * a = 1 :=
+  Invertible.invOf_mul_self
+
 theorem invOf_mul_self [Mul α] [One α] (a : α) [Invertible a] : ⅟ a * a = 1 :=
   Invertible.invOf_mul_self
 #align inv_of_mul_self invOf_mul_self
 
 @[simp]
+theorem mul_invOf_self' [Mul α] [One α] (a : α) {_ : Invertible a} : a * ⅟ a = 1 :=
+  Invertible.mul_invOf_self
+
 theorem mul_invOf_self [Mul α] [One α] (a : α) [Invertible a] : a * ⅟ a = 1 :=
   Invertible.mul_invOf_self
 #align mul_inv_of_self mul_invOf_self
 
 @[simp]
+theorem invOf_mul_self_assoc' [Monoid α] (a b : α) {_ : Invertible a} : ⅟ a * (a * b) = b := by
+  rw [← mul_assoc, invOf_mul_self, one_mul]
+
 theorem invOf_mul_self_assoc [Monoid α] (a b : α) [Invertible a] : ⅟ a * (a * b) = b := by
   rw [← mul_assoc, invOf_mul_self, one_mul]
 #align inv_of_mul_self_assoc invOf_mul_self_assoc
 
 @[simp]
+theorem mul_invOf_self_assoc' [Monoid α] (a b : α) {_ : Invertible a} : a * (⅟ a * b) = b := by
+  rw [← mul_assoc, mul_invOf_self, one_mul]
+
 theorem mul_invOf_self_assoc [Monoid α] (a b : α) [Invertible a] : a * (⅟ a * b) = b := by
   rw [← mul_assoc, mul_invOf_self, one_mul]
 #align mul_inv_of_self_assoc mul_invOf_self_assoc
 
 @[simp]
+theorem mul_invOf_mul_self_cancel' [Monoid α] (a b : α) {_ : Invertible b} : a * ⅟ b * b = a := by
+  simp [mul_assoc]
+
 theorem mul_invOf_mul_self_cancel [Monoid α] (a b : α) [Invertible b] : a * ⅟ b * b = a := by
   simp [mul_assoc]
 #align mul_inv_of_mul_self_cancel mul_invOf_mul_self_cancel
 
 @[simp]
+theorem mul_mul_invOf_self_cancel' [Monoid α] (a b : α) {_ : Invertible b} : a * b * ⅟ b = a := by
+  simp [mul_assoc]
+
 theorem mul_mul_invOf_self_cancel [Monoid α] (a b : α) [Invertible b] : a * b * ⅟ b = a := by
   simp [mul_assoc]
 #align mul_mul_inv_of_self_cancel mul_mul_invOf_self_cancel

Fix: to_additive doesn't translate numeral literals by default (#2726)

The numeral literal 1 only gets replaced by 0 in a few whitelisted declarations
The previous behavior was to replace the numeral 1 by the numeral 0 always, unless it occurs in a list of blacklisted declarations. However, norm_num and other tactics give proofs with many numeral literals in many different declarations, and these literals - I believe - always represent natural numbers. Therefore, we had to blacklist very many declarations. The new default improves the situation.

46137576

Diff

@@ -315,7 +315,6 @@ theorem nonzero_of_invertible [MulZeroOneClass α] (a : α) [Nontrivial α] [Inv
 
 #align nonzero_of_invertible nonzero_of_invertible
 
-@[to_additive_fixed_numeral 4]
 theorem pos_of_invertible_cast [Semiring α] [Nontrivial α] (n : ℕ) [Invertible (n : α)] : 0 < n :=
   Nat.zero_lt_of_ne_zero fun h => nonzero_of_invertible (n : α) (h ▸ Nat.cast_zero)

feat: accept rationals in positivity from norm_num (#2103)

See zulip.

Note that tests are few because most operations which are handled by norm_num are also handled by positivity. (More tests can be added when e.g. #1707 lands.)

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

7579f3b0

Diff

@@ -315,6 +315,10 @@ theorem nonzero_of_invertible [MulZeroOneClass α] (a : α) [Nontrivial α] [Inv
 
 #align nonzero_of_invertible nonzero_of_invertible
 
+@[to_additive_fixed_numeral 4]
+theorem pos_of_invertible_cast [Semiring α] [Nontrivial α] (n : ℕ) [Invertible (n : α)] : 0 < n :=
+  Nat.zero_lt_of_ne_zero fun h => nonzero_of_invertible (n : α) (h ▸ Nat.cast_zero)
+
 instance (priority := 100) Invertible.ne_zero [MulZeroOneClass α] [Nontrivial α] (a : α)
     [Invertible a] : NeZero a :=
   ⟨nonzero_of_invertible a⟩

feat: simps support additional simp-attributes (#2398)

Also fix the configuration option Simps.Config.lemmasOnly and use it in the library
Also use @[simps!] in the test file
Also remove the temporary configuration in LocalHomeomorph
Zulip thread
Fixes #2350

6c066e01

Diff

@@ -412,7 +412,7 @@ theorem map_invOf {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [Monoid
   then `r : R` is invertible if `f r` is.
 
 The inverse is computed as `g (⅟(f r))` -/
-@[simps! (config := { attrs := [] })]
+@[simps! (config := .lemmasOnly)]
 def Invertible.ofLeftInverse {R : Type _} {S : Type _} {G : Type _} [MulOneClass R] [MulOneClass S]
     [MonoidHomClass G S R] (f : R → S) (g : G) (r : R) (h : Function.LeftInverse g f)
     [Invertible (f r)] : Invertible r :=

feat: require @[simps!] if simps runs in expensive mode (#1885)

This does not change the behavior of simps, just raises a linter error if you run simps in a more expensive mode without writing !.
Fixed some incorrect occurrences of to_additive, simps. Will do that systematically in future PR.
Fix port of OmegaCompletePartialOrder.ContinuousHom.ofMono a bit

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

52c04a34

Diff

@@ -412,7 +412,7 @@ theorem map_invOf {R : Type _} {S : Type _} {F : Type _} [MulOneClass R] [Monoid
   then `r : R` is invertible if `f r` is.
 
 The inverse is computed as `g (⅟(f r))` -/
-@[simps (config := { attrs := [] })]
+@[simps! (config := { attrs := [] })]
 def Invertible.ofLeftInverse {R : Type _} {S : Type _} {G : Type _} [MulOneClass R] [MulOneClass S]
     [MonoidHomClass G S R] (f : R → S) (g : G) (r : R) (h : Function.LeftInverse g f)
     [Invertible (f r)] : Invertible r :=

chore: bump to nightly-2023-02-03 (#1999)

78fc778d

Diff

@@ -283,7 +283,6 @@ theorem mul_right_eq_iff_eq_mul_invOf [Monoid α] [Invertible (c : α)] :
 
 theorem Commute.invOf_right [Monoid α] {a b : α} [Invertible b] (h : Commute a b) :
     Commute a (⅟ b) :=
-  show _ = _ from -- lean4#2073
   calc
     a * ⅟ b = ⅟ b * (b * a * ⅟ b) := by simp [mul_assoc]
     _ = ⅟ b * (a * b * ⅟ b) := by rw [h.eq]
@@ -293,7 +292,6 @@ theorem Commute.invOf_right [Monoid α] {a b : α} [Invertible b] (h : Commute a
 
 theorem Commute.invOf_left [Monoid α] {a b : α} [Invertible b] (h : Commute b a) :
     Commute (⅟ b) a :=
-  show _ = _ from -- lean4#2073
   calc
     ⅟ b * a = ⅟ b * (a * b * ⅟ b) := by simp [mul_assoc]
     _ = ⅟ b * (b * a * ⅟ b) := by rw [h.eq]
@@ -302,7 +300,6 @@ theorem Commute.invOf_left [Monoid α] {a b : α} [Invertible b] (h : Commute b
 #align commute.inv_of_left Commute.invOf_left
 
 theorem commute_invOf {M : Type _} [One M] [Mul M] (m : M) [Invertible m] : Commute m (⅟ m) :=
-  show _ = _ from -- lean4#2073
   calc
     m * ⅟ m = 1 := mul_invOf_self m
     _ = ⅟ m * m := (invOf_mul_self m).symm

chore: bump lean 01-29 (#1927)

1abd74a8

Diff

@@ -283,6 +283,7 @@ theorem mul_right_eq_iff_eq_mul_invOf [Monoid α] [Invertible (c : α)] :
 
 theorem Commute.invOf_right [Monoid α] {a b : α} [Invertible b] (h : Commute a b) :
     Commute a (⅟ b) :=
+  show _ = _ from -- lean4#2073
   calc
     a * ⅟ b = ⅟ b * (b * a * ⅟ b) := by simp [mul_assoc]
     _ = ⅟ b * (a * b * ⅟ b) := by rw [h.eq]
@@ -292,6 +293,7 @@ theorem Commute.invOf_right [Monoid α] {a b : α} [Invertible b] (h : Commute a
 
 theorem Commute.invOf_left [Monoid α] {a b : α} [Invertible b] (h : Commute b a) :
     Commute (⅟ b) a :=
+  show _ = _ from -- lean4#2073
   calc
     ⅟ b * a = ⅟ b * (a * b * ⅟ b) := by simp [mul_assoc]
     _ = ⅟ b * (b * a * ⅟ b) := by rw [h.eq]
@@ -300,6 +302,7 @@ theorem Commute.invOf_left [Monoid α] {a b : α} [Invertible b] (h : Commute b
 #align commute.inv_of_left Commute.invOf_left
 
 theorem commute_invOf {M : Type _} [One M] [Mul M] (m : M) [Invertible m] : Commute m (⅟ m) :=
+  show _ = _ from -- lean4#2073
   calc
     m * ⅟ m = 1 := mul_invOf_self m
     _ = ⅟ m * m := (invOf_mul_self m).symm

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

@@ -418,6 +418,7 @@ def Invertible.ofLeftInverse {R : Type _} {S : Type _} {G : Type _} [MulOneClass
     [Invertible (f r)] : Invertible r :=
   (Invertible.map g (f r)).copy _ (h r).symm
 #align invertible.of_left_inverse Invertible.ofLeftInverse
+#align invertible.of_left_inverse_inv_of Invertible.ofLeftInverse_invOf
 
 /-- Invertibility on either side of a monoid hom with a left-inverse is equivalent. -/
 @[simps]
@@ -431,3 +432,5 @@ def invertibleEquivOfLeftInverse {R : Type _} {S : Type _} {F G : Type _} [Monoi
   left_inv _ := Subsingleton.elim _ _
   right_inv _ := Subsingleton.elim _ _
 #align invertible_equiv_of_left_inverse invertibleEquivOfLeftInverse
+#align invertible_equiv_of_left_inverse_symm_apply invertibleEquivOfLeftInverse_symm_apply
+#align invertible_equiv_of_left_inverse_apply invertibleEquivOfLeftInverse_apply

feat: =, ≠, <, and ≤ functionality for norm_num (#1568)

This PR gives norm_num basic inequality (and equality) functionality (towards #1567), including the following:

example {α} [DivisionRing α] [CharZero α] : (-1:α) ≠ 2 := by norm_num

We implement basic logical extensions to handle = and ≠ together, namely ¬, True, and False. ≠ is not given an extension, as it is handled by = and ¬.

For now we only can prove ≠ for numbers given a CharZero α instance.

depends on: #1578

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

3fbdae49

Diff

@@ -257,6 +257,30 @@ theorem invOf_mul [Monoid α] (a b : α) [Invertible a] [Invertible b] [Invertib
   invOf_eq_right_inv (by simp [← mul_assoc])
 #align inv_of_mul invOf_mul
 
+theorem mul_right_inj_of_invertible [Monoid α] (c : α) [Invertible c] :
+    a * c = b * c ↔ a = b :=
+  ⟨fun h => by simpa using congr_arg (· * ⅟c) h, congr_arg (· * _)⟩
+
+theorem mul_left_inj_of_invertible [Monoid α] (c : α) [Invertible c] :
+    c * a = c * b ↔ a = b :=
+  ⟨fun h => by simpa using congr_arg (⅟c * ·) h, congr_arg (_ * ·)⟩
+
+theorem invOf_mul_eq_iff_eq_mul_left [Monoid α] [Invertible (c : α)] :
+    ⅟c * a = b ↔ a = c * b := by
+  rw [← mul_left_inj_of_invertible (c := c), mul_invOf_self_assoc]
+
+theorem mul_left_eq_iff_eq_invOf_mul [Monoid α] [Invertible (c : α)] :
+    c * a = b ↔ a = ⅟c * b := by
+  rw [← mul_left_inj_of_invertible (c := ⅟c), invOf_mul_self_assoc]
+
+theorem mul_invOf_eq_iff_eq_mul_right [Monoid α] [Invertible (c : α)] :
+    a * ⅟c = b ↔ a = b * c := by
+  rw [← mul_right_inj_of_invertible (c := c), mul_invOf_mul_self_cancel]
+
+theorem mul_right_eq_iff_eq_mul_invOf [Monoid α] [Invertible (c : α)] :
+    a * c = b ↔ a = b * ⅟c := by
+  rw [← mul_right_inj_of_invertible (c := ⅟c), mul_mul_invOf_self_cancel]
+
 theorem Commute.invOf_right [Monoid α] {a b : α} [Invertible b] (h : Commute a b) :
     Commute a (⅟ b) :=
   calc

fix: sorries in Tactic.NormNum.Core (#1564)

24122eed

Diff

@@ -139,8 +139,8 @@ def Invertible.copy [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (hs :
 
 /-- If `a` is invertible and `a = b`, then `⅟a = ⅟b`. -/
 @[congr]
-theorem Invertible.cong [Ring α] (a b : α) [Invertible a] (h : a = b) :
-  ⅟a = @Invertible.invOf _ _ _ b (Invertible.copy ‹_› _ h.symm) := by subst h; rfl
+theorem Invertible.congr [Ring α] (a b : α) [Invertible a] [Invertible b] (h : a = b) :
+  ⅟a = ⅟b := by subst h; congr; apply Subsingleton.allEq
 
 /-- An `invertible` element is a unit. -/
 @[simps]

feat: Rat-dependent norm_num functionality (#1441)

As per #1102, we extend norm_num to handle Rats.

We leave most of the theorems sorried, but the evaluation and tests work!

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

3aaa8a54

Diff

@@ -137,6 +137,11 @@ def Invertible.copy [MulOneClass α] {r : α} (hr : Invertible r) (s : α) (hs :
   mul_invOf_self := by rw [hs, mul_invOf_self]
 #align invertible.copy Invertible.copy
 
+/-- If `a` is invertible and `a = b`, then `⅟a = ⅟b`. -/
+@[congr]
+theorem Invertible.cong [Ring α] (a b : α) [Invertible a] (h : a = b) :
+  ⅟a = @Invertible.invOf _ _ _ b (Invertible.copy ‹_› _ h.symm) := by subst h; rfl
+
 /-- An `invertible` element is a unit. -/
 @[simps]
 def unitOfInvertible [Monoid α] (a : α) [Invertible a] :
@@ -197,6 +202,9 @@ def invertibleOne [Monoid α] : Invertible (1 : α) :=
 #align invertible_one invertibleOne
 
 @[simp]
+theorem invOf_one' [Monoid α] {_ : Invertible (1 : α)} : ⅟ (1 : α) = 1 :=
+  invOf_eq_right_inv (mul_one _)
+
 theorem invOf_one [Monoid α] [Invertible (1 : α)] : ⅟ (1 : α) = 1 :=
   invOf_eq_right_inv (mul_one _)
 #align inv_of_one invOf_one

chore: fix more casing errors per naming scheme (#1232)

I've avoided anything under Tactic or test.

In correcting the names, I found Option.isNone_iff_eq_none duplicated between Std and Mathlib, so the Mathlib one has been removed.

Co-authored-by: Reid Barton <rwbarton@gmail.com>

31a56f75

Diff

@@ -292,7 +292,7 @@ section MonoidWithZero
 
 variable [MonoidWithZero α]
 
-/-- A variant of `ring.inverse_unit`. -/
+/-- A variant of `Ring.inverse_unit`. -/
 @[simp]
 theorem Ring.inverse_invertible (x : α) [Invertible x] : Ring.inverse x = ⅟ x :=
   Ring.inverse_unit (unitOfInvertible _)

chore: remove duplicated definition of Invertible class in NormNum.Core.lean (#1313)

Deletes the temporary Invertible class defined in NormNum.Core. This is possible because Algebra.Invertible landed in #930, and its dependence on NormNum was removed in #1055.
Updates the definition of the Invertible.toInv syntax to not require a space and to more closely match the Inv.inv syntax.

3b9e5d47

Diff

@@ -76,7 +76,7 @@ class Invertible [Mul α] [One α] (a : α) : Type u where
 #align invertible Invertible
 
 /-- The inverse of an `Invertible` element -/
-notation:1034
+prefix:max
   "⅟" =>-- This notation has the same precedence as `Inv.inv`.
   Invertible.invOf

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

@@ -77,7 +77,7 @@ class Invertible [Mul α] [One α] (a : α) : Type u where
 
 /-- The inverse of an `Invertible` element -/
 notation:1034
-  "⅟" =>-- This notation has the same precedence as `has_inv.inv`.
+  "⅟" =>-- This notation has the same precedence as `Inv.inv`.
   Invertible.invOf
 
 @[simp]
@@ -177,9 +177,9 @@ noncomputable def IsUnit.invertible [Monoid α] {a : α} (h : IsUnit a) : Invert
 #align is_unit.invertible IsUnit.invertible
 
 @[simp]
-theorem nonempty_invertible_iff_is_unit [Monoid α] (a : α) : Nonempty (Invertible a) ↔ IsUnit a :=
+theorem nonempty_invertible_iff_isUnit [Monoid α] (a : α) : Nonempty (Invertible a) ↔ IsUnit a :=
   ⟨Nonempty.rec <| @isUnit_of_invertible _ _ _, IsUnit.nonempty_invertible⟩
-#align nonempty_invertible_iff_is_unit nonempty_invertible_iff_is_unit
+#align nonempty_invertible_iff_is_unit nonempty_invertible_iff_isUnit
 
 /-- Each element of a group is invertible. -/
 def invertibleOfGroup [Group α] (a : α) : Invertible a :=

feat port Algebra.GroupPower.Lemmas (#1055)

aba57d4d

depends on #1043
depends on #1050

Co-authored-by: Siddhartha Gadgil <siddhartha.gadgil@gmail.com>

1bec125b

Diff

@@ -11,7 +11,6 @@ Authors: Anne Baanen
 import Mathlib.Algebra.Group.Units
 import Mathlib.Algebra.GroupWithZero.Units.Lemmas
 import Mathlib.Algebra.Ring.Defs
-import Mathlib.Tactic.NormNum
 /-!
 # Invertible elements
 
@@ -216,7 +215,7 @@ theorem invOf_neg [Monoid α] [HasDistribNeg α] (a : α) [Invertible a] [Invert
 @[simp]
 theorem one_sub_invOf_two [Ring α] [Invertible (2 : α)] : 1 - (⅟ 2 : α) = ⅟ 2 :=
   (isUnit_of_invertible (2 : α)).mul_right_inj.1 <| by
-    rw [mul_sub, mul_invOf_self, mul_one] ; norm_num
+    rw [mul_sub, mul_invOf_self, mul_one, ← one_add_one_eq_two, add_sub_cancel]
 #align one_sub_inv_of_two one_sub_invOf_two
 
 @[simp]