algebra.group.conj ⟷ Mathlib.Algebra.Group.Conj

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

@@ -3,10 +3,10 @@ Copyright (c) 2018 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Chris Hughes, Michael Howes
 -/
-import Algebra.Group.Semiconj
+import Algebra.Group.Semiconj.Defs
 import Algebra.GroupWithZero.Basic
-import Algebra.Hom.Aut
-import Algebra.Hom.Group
+import Algebra.Group.Aut
+import Algebra.Group.Hom.Defs
 
 #align_import algebra.group.conj from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
 
@@ -138,7 +138,7 @@ theorem conj_pow {i : ℕ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻
   by
   induction' i with i hi
   · simp
-  · simp [pow_succ, hi]
+  · simp [pow_succ', hi]
 #align conj_pow conj_pow
 -/
 

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

@@ -67,7 +67,7 @@ theorem IsConj.trans {a b c : α} : IsConj a b → IsConj b c → IsConj a c
 theorem isConj_iff_eq {α : Type _} [CommMonoid α] {a b : α} : IsConj a b ↔ a = b :=
   ⟨fun ⟨c, hc⟩ =>
     by
-    rw [SemiconjBy, mul_comm, ← Units.mul_inv_eq_iff_eq_mul, mul_assoc, c.mul_inv, mul_one] at hc 
+    rw [SemiconjBy, mul_comm, ← Units.mul_inv_eq_iff_eq_mul, mul_assoc, c.mul_inv, mul_one] at hc
     exact hc, fun h => by rw [h]⟩
 #align is_conj_iff_eq isConj_iff_eq
 -/
@@ -373,7 +373,7 @@ theorem isConj_iff_conjugatesOf_eq {a b : α} : IsConj a b ↔ conjugatesOf a =
   ⟨IsConj.conjugatesOf_eq, fun h =>
     by
     have ha := mem_conjugatesOf_self
-    rwa [← h] at ha ⟩
+    rwa [← h] at ha⟩
 #align is_conj_iff_conjugates_of_eq isConj_iff_conjugatesOf_eq
 -/
 

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

@@ -3,10 +3,10 @@ Copyright (c) 2018 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Chris Hughes, Michael Howes
 -/
-import Mathbin.Algebra.Group.Semiconj
-import Mathbin.Algebra.GroupWithZero.Basic
-import Mathbin.Algebra.Hom.Aut
-import Mathbin.Algebra.Hom.Group
+import Algebra.Group.Semiconj
+import Algebra.GroupWithZero.Basic
+import Algebra.Hom.Aut
+import Algebra.Hom.Group
 
 #align_import algebra.group.conj from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
 

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

@@ -128,7 +128,7 @@ theorem conj_inv {a b : α} : (b * a * b⁻¹)⁻¹ = b * a⁻¹ * b⁻¹ :=
 #print conj_mul /-
 @[simp]
 theorem conj_mul {a b c : α} : b * a * b⁻¹ * (b * c * b⁻¹) = b * (a * c) * b⁻¹ :=
-  ((MulAut.conj b).map_mul a c).symm
+  ((MulAut.conj b).map_hMul a c).symm
 #align conj_mul conj_mul
 -/
 

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

@@ -2,17 +2,14 @@
 Copyright (c) 2018 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Chris Hughes, Michael Howes
-
-! This file was ported from Lean 3 source module algebra.group.conj
-! leanprover-community/mathlib commit c3291da49cfa65f0d43b094750541c0731edc932
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Group.Semiconj
 import Mathbin.Algebra.GroupWithZero.Basic
 import Mathbin.Algebra.Hom.Aut
 import Mathbin.Algebra.Hom.Group
 
+#align_import algebra.group.conj from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
+
 /-!
 # Conjugacy of group elements
 

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

@@ -75,9 +75,11 @@ theorem isConj_iff_eq {α : Type _} [CommMonoid α] {a b : α} : IsConj a b ↔
 #align is_conj_iff_eq isConj_iff_eq
 -/
 
+#print MonoidHom.map_isConj /-
 protected theorem MonoidHom.map_isConj (f : α →* β) {a b : α} : IsConj a b → IsConj (f a) (f b)
   | ⟨c, hc⟩ => ⟨Units.map f c, by rw [Units.coe_map, SemiconjBy, ← f.map_mul, hc.eq, f.map_mul]⟩
 #align monoid_hom.map_is_conj MonoidHom.map_isConj
+-/
 
 end Monoid
 
@@ -85,6 +87,7 @@ section CancelMonoid
 
 variable [CancelMonoid α]
 
+#print isConj_one_right /-
 -- These lemmas hold for `right_cancel_monoid` with the current proofs, but for the sake of
 -- not duplicating code (these lemmas also hold for `left_cancel_monoids`) we leave these
 -- not generalised.
@@ -93,13 +96,16 @@ theorem isConj_one_right {a : α} : IsConj 1 a ↔ a = 1 :=
   ⟨fun ⟨c, hc⟩ => mul_right_cancel (hc.symm.trans ((mul_one _).trans (one_mul _).symm)), fun h => by
     rw [h]⟩
 #align is_conj_one_right isConj_one_right
+-/
 
+#print isConj_one_left /-
 @[simp]
 theorem isConj_one_left {a : α} : IsConj a 1 ↔ a = 1 :=
   calc
     IsConj a 1 ↔ IsConj 1 a := ⟨IsConj.symm, IsConj.symm⟩
     _ ↔ a = 1 := isConj_one_right
 #align is_conj_one_left isConj_one_left
+-/
 
 end CancelMonoid
 
@@ -107,22 +113,29 @@ section Group
 
 variable [Group α]
 
+#print isConj_iff /-
 @[simp]
 theorem isConj_iff {a b : α} : IsConj a b ↔ ∃ c : α, c * a * c⁻¹ = b :=
   ⟨fun ⟨c, hc⟩ => ⟨c, mul_inv_eq_iff_eq_mul.2 hc⟩, fun ⟨c, hc⟩ =>
     ⟨⟨c, c⁻¹, mul_inv_self c, inv_mul_self c⟩, mul_inv_eq_iff_eq_mul.1 hc⟩⟩
 #align is_conj_iff isConj_iff
+-/
 
+#print conj_inv /-
 @[simp]
 theorem conj_inv {a b : α} : (b * a * b⁻¹)⁻¹ = b * a⁻¹ * b⁻¹ :=
   ((MulAut.conj b).map_inv a).symm
 #align conj_inv conj_inv
+-/
 
+#print conj_mul /-
 @[simp]
 theorem conj_mul {a b c : α} : b * a * b⁻¹ * (b * c * b⁻¹) = b * (a * c) * b⁻¹ :=
   ((MulAut.conj b).map_mul a c).symm
 #align conj_mul conj_mul
+-/
 
+#print conj_pow /-
 @[simp]
 theorem conj_pow {i : ℕ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹ :=
   by
@@ -130,7 +143,9 @@ theorem conj_pow {i : ℕ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻
   · simp
   · simp [pow_succ, hi]
 #align conj_pow conj_pow
+-/
 
+#print conj_zpow /-
 @[simp]
 theorem conj_zpow {i : ℤ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹ :=
   by
@@ -138,13 +153,17 @@ theorem conj_zpow {i : ℤ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻
   · simp
   · simp [zpow_negSucc, conj_pow]
 #align conj_zpow conj_zpow
+-/
 
+#print conj_injective /-
 theorem conj_injective {x : α} : Function.Injective fun g : α => x * g * x⁻¹ :=
   (MulAut.conj x).Injective
 #align conj_injective conj_injective
+-/
 
 end Group
 
+#print isConj_iff₀ /-
 @[simp]
 theorem isConj_iff₀ [GroupWithZero α] {a b : α} : IsConj a b ↔ ∃ c : α, c ≠ 0 ∧ c * a * c⁻¹ = b :=
   ⟨fun ⟨c, hc⟩ =>
@@ -157,6 +176,7 @@ theorem isConj_iff₀ [GroupWithZero α] {a b : α} : IsConj a b ↔ ∃ c : α,
       rw [SemiconjBy, ← Units.mul_inv_eq_iff_eq_mul, Units.val_inv_eq_inv_val, Units.val_mk0]
       exact hc⟩⟩
 #align is_conj_iff₀ isConj_iff₀
+-/
 
 namespace IsConj
 
@@ -231,9 +251,11 @@ theorem mk_surjective : Function.Surjective (@ConjClasses.mk α _) :=
 instance : One (ConjClasses α) :=
   ⟨⟦1⟧⟩
 
+#print ConjClasses.one_eq_mk_one /-
 theorem one_eq_mk_one : (1 : ConjClasses α) = ConjClasses.mk 1 :=
   rfl
 #align conj_classes.one_eq_mk_one ConjClasses.one_eq_mk_one
+-/
 
 #print ConjClasses.exists_rep /-
 theorem exists_rep (a : ConjClasses α) : ∃ a0 : α, ConjClasses.mk a0 = a :=
@@ -248,6 +270,7 @@ def map (f : α →* β) : ConjClasses α → ConjClasses β :=
 #align conj_classes.map ConjClasses.map
 -/
 
+#print ConjClasses.map_surjective /-
 theorem map_surjective {f : α →* β} (hf : Function.Surjective f) :
     Function.Surjective (ConjClasses.map f) :=
   by
@@ -256,6 +279,7 @@ theorem map_surjective {f : α →* β} (hf : Function.Surjective f) :
   obtain ⟨a, rfl⟩ := hf b
   exact ⟨ConjClasses.mk a, rfl⟩
 #align conj_classes.map_surjective ConjClasses.map_surjective
+-/
 
 library_note "slow-failing instance priority"/--
 Certain instances trigger further searches when they are considered as candidate instances;

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

@@ -99,7 +99,6 @@ theorem isConj_one_left {a : α} : IsConj a 1 ↔ a = 1 :=
   calc
     IsConj a 1 ↔ IsConj 1 a := ⟨IsConj.symm, IsConj.symm⟩
     _ ↔ a = 1 := isConj_one_right
-    
 #align is_conj_one_left isConj_one_left
 
 end CancelMonoid

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

@@ -332,7 +332,7 @@ variable [Monoid α]
 #print conjugatesOf /-
 /-- Given an element `a`, `conjugates a` is the set of conjugates. -/
 def conjugatesOf (a : α) : Set α :=
-  { b | IsConj a b }
+  {b | IsConj a b}
 #align conjugates_of conjugatesOf
 -/
 

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

@@ -70,7 +70,7 @@ theorem IsConj.trans {a b c : α} : IsConj a b → IsConj b c → IsConj a c
 theorem isConj_iff_eq {α : Type _} [CommMonoid α] {a b : α} : IsConj a b ↔ a = b :=
   ⟨fun ⟨c, hc⟩ =>
     by
-    rw [SemiconjBy, mul_comm, ← Units.mul_inv_eq_iff_eq_mul, mul_assoc, c.mul_inv, mul_one] at hc
+    rw [SemiconjBy, mul_comm, ← Units.mul_inv_eq_iff_eq_mul, mul_assoc, c.mul_inv, mul_one] at hc 
     exact hc, fun h => by rw [h]⟩
 #align is_conj_iff_eq isConj_iff_eq
 -/
@@ -353,7 +353,7 @@ theorem isConj_iff_conjugatesOf_eq {a b : α} : IsConj a b ↔ conjugatesOf a =
   ⟨IsConj.conjugatesOf_eq, fun h =>
     by
     have ha := mem_conjugatesOf_self
-    rwa [← h] at ha⟩
+    rwa [← h] at ha ⟩
 #align is_conj_iff_conjugates_of_eq isConj_iff_conjugatesOf_eq
 -/
 

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

@@ -75,12 +75,6 @@ theorem isConj_iff_eq {α : Type _} [CommMonoid α] {a b : α} : IsConj a b ↔
 #align is_conj_iff_eq isConj_iff_eq
 -/
 
-/- warning: monoid_hom.map_is_conj -> MonoidHom.map_isConj is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] (f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) {a : α} {b : α}, (IsConj.{u1} α _inst_1 a b) -> (IsConj.{u2} β _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) (fun (_x : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) => α -> β) (MonoidHom.hasCoeToFun.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) f a) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) (fun (_x : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) => α -> β) (MonoidHom.hasCoeToFun.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) f b))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] (f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) {a : α} {b : α}, (IsConj.{u1} α _inst_1 a b) -> (IsConj.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) a) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f b))
-Case conversion may be inaccurate. Consider using '#align monoid_hom.map_is_conj MonoidHom.map_isConjₓ'. -/
 protected theorem MonoidHom.map_isConj (f : α →* β) {a b : α} : IsConj a b → IsConj (f a) (f b)
   | ⟨c, hc⟩ => ⟨Units.map f c, by rw [Units.coe_map, SemiconjBy, ← f.map_mul, hc.eq, f.map_mul]⟩
 #align monoid_hom.map_is_conj MonoidHom.map_isConj
@@ -91,12 +85,6 @@ section CancelMonoid
 
 variable [CancelMonoid α]
 
-/- warning: is_conj_one_right -> isConj_one_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoid.{u1} α] {a : α}, Iff (IsConj.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α _inst_1))))))) a) (Eq.{succ u1} α a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoid.{u1} α] {a : α}, Iff (IsConj.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (RightCancelMonoid.toOne.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α _inst_1)))) a) (Eq.{succ u1} α a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (RightCancelMonoid.toOne.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align is_conj_one_right isConj_one_rightₓ'. -/
 -- These lemmas hold for `right_cancel_monoid` with the current proofs, but for the sake of
 -- not duplicating code (these lemmas also hold for `left_cancel_monoids`) we leave these
 -- not generalised.
@@ -106,12 +94,6 @@ theorem isConj_one_right {a : α} : IsConj 1 a ↔ a = 1 :=
     rw [h]⟩
 #align is_conj_one_right isConj_one_right
 
-/- warning: is_conj_one_left -> isConj_one_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoid.{u1} α] {a : α}, Iff (IsConj.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α _inst_1)) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α _inst_1)))))))) (Eq.{succ u1} α a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoid.{u1} α] {a : α}, Iff (IsConj.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α _inst_1)) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (RightCancelMonoid.toOne.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α _inst_1))))) (Eq.{succ u1} α a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (RightCancelMonoid.toOne.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align is_conj_one_left isConj_one_leftₓ'. -/
 @[simp]
 theorem isConj_one_left {a : α} : IsConj a 1 ↔ a = 1 :=
   calc
@@ -126,46 +108,22 @@ section Group
 
 variable [Group α]
 
-/- warning: is_conj_iff -> isConj_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {a : α} {b : α}, Iff (IsConj.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a b) (Exists.{succ u1} α (fun (c : α) => Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) c a) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) c)) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {a : α} {b : α}, Iff (IsConj.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a b) (Exists.{succ u1} α (fun (c : α) => Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) c a) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) c)) b))
-Case conversion may be inaccurate. Consider using '#align is_conj_iff isConj_iffₓ'. -/
 @[simp]
 theorem isConj_iff {a b : α} : IsConj a b ↔ ∃ c : α, c * a * c⁻¹ = b :=
   ⟨fun ⟨c, hc⟩ => ⟨c, mul_inv_eq_iff_eq_mul.2 hc⟩, fun ⟨c, hc⟩ =>
     ⟨⟨c, c⁻¹, mul_inv_self c, inv_mul_self c⟩, mul_inv_eq_iff_eq_mul.1 hc⟩⟩
 #align is_conj_iff isConj_iff
 
-/- warning: conj_inv -> conj_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {a : α} {b : α}, Eq.{succ u1} α (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b a) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {a : α} {b : α}, Eq.{succ u1} α (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b a) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a)) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b))
-Case conversion may be inaccurate. Consider using '#align conj_inv conj_invₓ'. -/
 @[simp]
 theorem conj_inv {a b : α} : (b * a * b⁻¹)⁻¹ = b * a⁻¹ * b⁻¹ :=
   ((MulAut.conj b).map_inv a).symm
 #align conj_inv conj_inv
 
-/- warning: conj_mul -> conj_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {a : α} {b : α} {c : α}, Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b a) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a c)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {a : α} {b : α} {c : α}, Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b a) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a c)) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b))
-Case conversion may be inaccurate. Consider using '#align conj_mul conj_mulₓ'. -/
 @[simp]
 theorem conj_mul {a b c : α} : b * a * b⁻¹ * (b * c * b⁻¹) = b * (a * c) * b⁻¹ :=
   ((MulAut.conj b).map_mul a c).symm
 #align conj_mul conj_mul
 
-/- warning: conj_pow -> conj_pow is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {i : Nat} {a : α} {b : α}, Eq.{succ u1} α (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a)) i) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) b i)) (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} α] {i : Nat} {a : α} {b : α}, Eq.{succ u1} α (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a)) i) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) b i)) (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 conj_pow conj_powₓ'. -/
 @[simp]
 theorem conj_pow {i : ℕ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹ :=
   by
@@ -174,12 +132,6 @@ theorem conj_pow {i : ℕ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻
   · simp [pow_succ, hi]
 #align conj_pow conj_pow
 
-/- warning: conj_zpow -> conj_zpow is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {i : Int} {a : α} {b : α}, Eq.{succ u1} α (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a)) i) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) b i)) (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} α] {i : Int} {a : α} {b : α}, Eq.{succ u1} α (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a)) i) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) b i)) (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 conj_zpow conj_zpowₓ'. -/
 @[simp]
 theorem conj_zpow {i : ℤ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹ :=
   by
@@ -188,24 +140,12 @@ theorem conj_zpow {i : ℤ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻
   · simp [zpow_negSucc, conj_pow]
 #align conj_zpow conj_zpow
 
-/- warning: conj_injective -> conj_injective is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {x : α}, Function.Injective.{succ u1, succ u1} α α (fun (g : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x g) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {x : α}, Function.Injective.{succ u1, succ u1} α α (fun (g : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x g) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) x))
-Case conversion may be inaccurate. Consider using '#align conj_injective conj_injectiveₓ'. -/
 theorem conj_injective {x : α} : Function.Injective fun g : α => x * g * x⁻¹ :=
   (MulAut.conj x).Injective
 #align conj_injective conj_injective
 
 end Group
 
-/- warning: is_conj_iff₀ -> isConj_iff₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] {a : α} {b : α}, Iff (IsConj.{u1} α (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)) a b) (Exists.{succ u1} α (fun (c : α) => And (Ne.{succ u1} α c (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)))))))) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) c a) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1)) c)) b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] {a : α} {b : α}, Iff (IsConj.{u1} α (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)) a b) (Exists.{succ u1} α (fun (c : α) => And (Ne.{succ u1} α c (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) c a) (Inv.inv.{u1} α (GroupWithZero.toInv.{u1} α _inst_1) c)) b)))
-Case conversion may be inaccurate. Consider using '#align is_conj_iff₀ isConj_iff₀ₓ'. -/
 @[simp]
 theorem isConj_iff₀ [GroupWithZero α] {a b : α} : IsConj a b ↔ ∃ c : α, c ≠ 0 ∧ c * a * c⁻¹ = b :=
   ⟨fun ⟨c, hc⟩ =>
@@ -292,12 +232,6 @@ theorem mk_surjective : Function.Surjective (@ConjClasses.mk α _) :=
 instance : One (ConjClasses α) :=
   ⟨⟦1⟧⟩
 
-/- warning: conj_classes.one_eq_mk_one -> ConjClasses.one_eq_mk_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (ConjClasses.{u1} α _inst_1) (OfNat.ofNat.{u1} (ConjClasses.{u1} α _inst_1) 1 (OfNat.mk.{u1} (ConjClasses.{u1} α _inst_1) 1 (One.one.{u1} (ConjClasses.{u1} α _inst_1) (ConjClasses.hasOne.{u1} α _inst_1)))) (ConjClasses.mk.{u1} α _inst_1 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (ConjClasses.{u1} α _inst_1) (OfNat.ofNat.{u1} (ConjClasses.{u1} α _inst_1) 1 (One.toOfNat1.{u1} (ConjClasses.{u1} α _inst_1) (ConjClasses.instOneConjClasses.{u1} α _inst_1))) (ConjClasses.mk.{u1} α _inst_1 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align conj_classes.one_eq_mk_one ConjClasses.one_eq_mk_oneₓ'. -/
 theorem one_eq_mk_one : (1 : ConjClasses α) = ConjClasses.mk 1 :=
   rfl
 #align conj_classes.one_eq_mk_one ConjClasses.one_eq_mk_one
@@ -315,12 +249,6 @@ def map (f : α →* β) : ConjClasses α → ConjClasses β :=
 #align conj_classes.map ConjClasses.map
 -/
 
-/- warning: conj_classes.map_surjective -> ConjClasses.map_surjective is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] {f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)}, (Function.Surjective.{succ u1, succ u2} α β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) (fun (_x : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) => α -> β) (MonoidHom.hasCoeToFun.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) f)) -> (Function.Surjective.{succ u1, succ u2} (ConjClasses.{u1} α _inst_1) (ConjClasses.{u2} β _inst_2) (ConjClasses.map.{u1, u2} α β _inst_1 _inst_2 f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] {f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)}, (Function.Surjective.{succ u1, succ u2} α β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f)) -> (Function.Surjective.{succ u1, succ u2} (ConjClasses.{u1} α _inst_1) (ConjClasses.{u2} β _inst_2) (ConjClasses.map.{u1, u2} α β _inst_1 _inst_2 f))
-Case conversion may be inaccurate. Consider using '#align conj_classes.map_surjective ConjClasses.map_surjectiveₓ'. -/
 theorem map_surjective {f : α →* β} (hf : Function.Surjective f) :
     Function.Surjective (ConjClasses.map f) :=
   by

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

@@ -79,7 +79,7 @@ theorem isConj_iff_eq {α : Type _} [CommMonoid α] {a b : α} : IsConj a b ↔
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] (f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) {a : α} {b : α}, (IsConj.{u1} α _inst_1 a b) -> (IsConj.{u2} β _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) (fun (_x : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) => α -> β) (MonoidHom.hasCoeToFun.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) f a) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) (fun (_x : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) => α -> β) (MonoidHom.hasCoeToFun.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) f b))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] (f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) {a : α} {b : α}, (IsConj.{u1} α _inst_1 a b) -> (IsConj.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) a) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f b))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] (f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) {a : α} {b : α}, (IsConj.{u1} α _inst_1 a b) -> (IsConj.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) a) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f b))
 Case conversion may be inaccurate. Consider using '#align monoid_hom.map_is_conj MonoidHom.map_isConjₓ'. -/
 protected theorem MonoidHom.map_isConj (f : α →* β) {a b : α} : IsConj a b → IsConj (f a) (f b)
   | ⟨c, hc⟩ => ⟨Units.map f c, by rw [Units.coe_map, SemiconjBy, ← f.map_mul, hc.eq, f.map_mul]⟩
@@ -319,7 +319,7 @@ def map (f : α →* β) : ConjClasses α → ConjClasses β :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] {f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)}, (Function.Surjective.{succ u1, succ u2} α β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) (fun (_x : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) => α -> β) (MonoidHom.hasCoeToFun.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) f)) -> (Function.Surjective.{succ u1, succ u2} (ConjClasses.{u1} α _inst_1) (ConjClasses.{u2} β _inst_2) (ConjClasses.map.{u1, u2} α β _inst_1 _inst_2 f))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] {f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)}, (Function.Surjective.{succ u1, succ u2} α β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f)) -> (Function.Surjective.{succ u1, succ u2} (ConjClasses.{u1} α _inst_1) (ConjClasses.{u2} β _inst_2) (ConjClasses.map.{u1, u2} α β _inst_1 _inst_2 f))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] {f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)}, (Function.Surjective.{succ u1, succ u2} α β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f)) -> (Function.Surjective.{succ u1, succ u2} (ConjClasses.{u1} α _inst_1) (ConjClasses.{u2} β _inst_2) (ConjClasses.map.{u1, u2} α β _inst_1 _inst_2 f))
 Case conversion may be inaccurate. Consider using '#align conj_classes.map_surjective ConjClasses.map_surjectiveₓ'. -/
 theorem map_surjective {f : α →* β} (hf : Function.Surjective f) :
     Function.Surjective (ConjClasses.map f) :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/09079525fd01b3dda35e96adaa08d2f943e1648c

@@ -234,7 +234,7 @@ protected def setoid (α : Type _) [Monoid α] : Setoid α
 
 end IsConj
 
-attribute [local instance] IsConj.setoid
+attribute [local instance 100] IsConj.setoid
 
 #print ConjClasses /-
 /-- The quotient type of conjugacy classes of a group. -/

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

@@ -79,7 +79,7 @@ theorem isConj_iff_eq {α : Type _} [CommMonoid α] {a b : α} : IsConj a b ↔
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] (f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) {a : α} {b : α}, (IsConj.{u1} α _inst_1 a b) -> (IsConj.{u2} β _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) (fun (_x : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) => α -> β) (MonoidHom.hasCoeToFun.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) f a) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) (fun (_x : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) => α -> β) (MonoidHom.hasCoeToFun.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) f b))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] (f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) {a : α} {b : α}, (IsConj.{u1} α _inst_1 a b) -> (IsConj.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) a) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f b))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] (f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) {a : α} {b : α}, (IsConj.{u1} α _inst_1 a b) -> (IsConj.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) a) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f b))
 Case conversion may be inaccurate. Consider using '#align monoid_hom.map_is_conj MonoidHom.map_isConjₓ'. -/
 protected theorem MonoidHom.map_isConj (f : α →* β) {a b : α} : IsConj a b → IsConj (f a) (f b)
   | ⟨c, hc⟩ => ⟨Units.map f c, by rw [Units.coe_map, SemiconjBy, ← f.map_mul, hc.eq, f.map_mul]⟩
@@ -319,7 +319,7 @@ def map (f : α →* β) : ConjClasses α → ConjClasses β :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] {f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)}, (Function.Surjective.{succ u1, succ u2} α β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) (fun (_x : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) => α -> β) (MonoidHom.hasCoeToFun.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) f)) -> (Function.Surjective.{succ u1, succ u2} (ConjClasses.{u1} α _inst_1) (ConjClasses.{u2} β _inst_2) (ConjClasses.map.{u1, u2} α β _inst_1 _inst_2 f))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] {f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)}, (Function.Surjective.{succ u1, succ u2} α β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f)) -> (Function.Surjective.{succ u1, succ u2} (ConjClasses.{u1} α _inst_1) (ConjClasses.{u2} β _inst_2) (ConjClasses.map.{u1, u2} α β _inst_1 _inst_2 f))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] {f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)}, (Function.Surjective.{succ u1, succ u2} α β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f)) -> (Function.Surjective.{succ u1, succ u2} (ConjClasses.{u1} α _inst_1) (ConjClasses.{u2} β _inst_2) (ConjClasses.map.{u1, u2} α β _inst_1 _inst_2 f))
 Case conversion may be inaccurate. Consider using '#align conj_classes.map_surjective ConjClasses.map_surjectiveₓ'. -/
 theorem map_surjective {f : α →* β} (hf : Function.Surjective f) :
     Function.Surjective (ConjClasses.map f) :=

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

@@ -79,7 +79,7 @@ theorem isConj_iff_eq {α : Type _} [CommMonoid α] {a b : α} : IsConj a b ↔
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] (f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) {a : α} {b : α}, (IsConj.{u1} α _inst_1 a b) -> (IsConj.{u2} β _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) (fun (_x : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) => α -> β) (MonoidHom.hasCoeToFun.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) f a) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) (fun (_x : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) => α -> β) (MonoidHom.hasCoeToFun.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) f b))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] (f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) {a : α} {b : α}, (IsConj.{u1} α _inst_1 a b) -> (IsConj.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) a) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f b))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] (f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) {a : α} {b : α}, (IsConj.{u1} α _inst_1 a b) -> (IsConj.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) a) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f b))
 Case conversion may be inaccurate. Consider using '#align monoid_hom.map_is_conj MonoidHom.map_isConjₓ'. -/
 protected theorem MonoidHom.map_isConj (f : α →* β) {a b : α} : IsConj a b → IsConj (f a) (f b)
   | ⟨c, hc⟩ => ⟨Units.map f c, by rw [Units.coe_map, SemiconjBy, ← f.map_mul, hc.eq, f.map_mul]⟩
@@ -319,7 +319,7 @@ def map (f : α →* β) : ConjClasses α → ConjClasses β :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] {f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)}, (Function.Surjective.{succ u1, succ u2} α β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) (fun (_x : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) => α -> β) (MonoidHom.hasCoeToFun.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) f)) -> (Function.Surjective.{succ u1, succ u2} (ConjClasses.{u1} α _inst_1) (ConjClasses.{u2} β _inst_2) (ConjClasses.map.{u1, u2} α β _inst_1 _inst_2 f))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] {f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)}, (Function.Surjective.{succ u1, succ u2} α β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f)) -> (Function.Surjective.{succ u1, succ u2} (ConjClasses.{u1} α _inst_1) (ConjClasses.{u2} β _inst_2) (ConjClasses.map.{u1, u2} α β _inst_1 _inst_2 f))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Monoid.{u2} β] {f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)}, (Function.Surjective.{succ u1, succ u2} α β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)) α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2) (MonoidHom.monoidHomClass.{u1, u2} α β (Monoid.toMulOneClass.{u1} α _inst_1) (Monoid.toMulOneClass.{u2} β _inst_2)))) f)) -> (Function.Surjective.{succ u1, succ u2} (ConjClasses.{u1} α _inst_1) (ConjClasses.{u2} β _inst_2) (ConjClasses.map.{u1, u2} α β _inst_1 _inst_2 f))
 Case conversion may be inaccurate. Consider using '#align conj_classes.map_surjective ConjClasses.map_surjectiveₓ'. -/
 theorem map_surjective {f : α →* β} (hf : Function.Surjective f) :
     Function.Surjective (ConjClasses.map f) :=

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

@@ -244,7 +244,7 @@ the instance priority should be even lower, see Note [lower instance priority].
 
 -- see Note [slow-failing instance priority]
 instance (priority := 900) [DecidableRel (IsConj : α → α → Prop)] : DecidableEq (ConjClasses α) :=
-  instDecidableEqQuotient
+  inferInstanceAs <| DecidableEq <| Quotient (IsConj.setoid α)
 
 end Monoid
 

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

@@ -265,7 +265,7 @@ def mkEquiv : α ≃ ConjClasses α :=
   ⟨ConjClasses.mk, Quotient.lift id fun (a : α) b => isConj_iff_eq.1, Quotient.lift_mk _ _, by
     rw [Function.RightInverse, Function.LeftInverse, forall_isConj]
     intro x
-    rw [← quotient_mk_eq_mk, ← quotient_mk_eq_mk, Quotient.lift_mk, id.def]⟩
+    rw [← quotient_mk_eq_mk, ← quotient_mk_eq_mk, Quotient.lift_mk, id]⟩
 #align conj_classes.mk_equiv ConjClasses.mkEquiv
 
 end CommMonoid

... and add a deprecated alias for the old name. This is mostly just me discovering the power of F2

@@ -113,10 +113,10 @@ theorem conj_pow {i : ℕ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻
 theorem conj_zpow {i : ℤ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹ := by
   induction' i
   · change (a * b * a⁻¹) ^ (_ : ℤ) = a * b ^ (_ : ℤ) * a⁻¹
-    simp [zpow_coe_nat]
+    simp [zpow_natCast]
   · simp only [zpow_negSucc, conj_pow, mul_inv_rev, inv_inv]
     rw [mul_assoc]
--- Porting note: Added `change`, `zpow_coe_nat`, and `rw`.
+-- Porting note: Added `change`, `zpow_natCast`, and `rw`.
 #align conj_zpow conj_zpow
 
 theorem conj_injective {x : α} : Function.Injective fun g : α => x * g * x⁻¹ :=

The squeezing continues! All found by the linter at #11246.

@@ -114,7 +114,7 @@ theorem conj_zpow {i : ℤ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻
   induction' i
   · change (a * b * a⁻¹) ^ (_ : ℤ) = a * b ^ (_ : ℤ) * a⁻¹
     simp [zpow_coe_nat]
-  · simp [zpow_negSucc, conj_pow]
+  · simp only [zpow_negSucc, conj_pow, mul_inv_rev, inv_inv]
     rw [mul_assoc]
 -- Porting note: Added `change`, `zpow_coe_nat`, and `rw`.
 #align conj_zpow conj_zpow

Previously these were syntactically identical to the corresponding zpow_coe_nat and coe_nat_zsmul lemmas, now they are about OfNat.ofNat.

Unfortunately, almost every call site uses the ofNat name to refer to Nat.cast, so the downstream proofs had to be adjusted too.

@@ -113,10 +113,10 @@ theorem conj_pow {i : ℕ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻
 theorem conj_zpow {i : ℤ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹ := by
   induction' i
   · change (a * b * a⁻¹) ^ (_ : ℤ) = a * b ^ (_ : ℤ) * a⁻¹
-    simp [zpow_ofNat]
+    simp [zpow_coe_nat]
   · simp [zpow_negSucc, conj_pow]
     rw [mul_assoc]
--- Porting note: Added `change`, `zpow_ofNat`, and `rw`.
+-- Porting note: Added `change`, `zpow_coe_nat`, and `rw`.
 #align conj_zpow conj_zpow
 
 theorem conj_injective {x : α} : Function.Injective fun g : α => x * g * x⁻¹ :=

These lemmas can be proved much earlier with little to no change to their proofs.

Part of #9411

@@ -4,9 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Chris Hughes, Michael Howes
 -/
 import Mathlib.Algebra.Group.Aut
-import Mathlib.Algebra.Group.Hom.Defs
-import Mathlib.Algebra.Group.Semiconj.Defs
-import Mathlib.Algebra.GroupWithZero.Basic
+import Mathlib.Algebra.Group.Semiconj.Units
 
 #align_import algebra.group.conj from "leanprover-community/mathlib"@"0743cc5d9d86bcd1bba10f480e948a257d65056f"
 

I believe the file defining a type of morphisms belongs alongside the file defining the structure this morphism works on. So I would like to reorganize the files in the Mathlib.Algebra.Hom folder so that e.g. Mathlib.Algebra.Hom.Ring becomes Mathlib.Algebra.Ring.Hom and Mathlib.Algebra.Hom.NonUnitalAlg becomes Mathlib.Algebra.Algebra.NonUnitalHom.

While fixing the imports I went ahead and sorted them for good luck.

The full list of changes is: renamed: Mathlib/Algebra/Hom/NonUnitalAlg.lean -> Mathlib/Algebra/Algebra/NonUnitalHom.lean renamed: Mathlib/Algebra/Hom/Aut.lean -> Mathlib/Algebra/Group/Aut.lean renamed: Mathlib/Algebra/Hom/Commute.lean -> Mathlib/Algebra/Group/Commute/Hom.lean renamed: Mathlib/Algebra/Hom/Embedding.lean -> Mathlib/Algebra/Group/Embedding.lean renamed: Mathlib/Algebra/Hom/Equiv/Basic.lean -> Mathlib/Algebra/Group/Equiv/Basic.lean renamed: Mathlib/Algebra/Hom/Equiv/TypeTags.lean -> Mathlib/Algebra/Group/Equiv/TypeTags.lean renamed: Mathlib/Algebra/Hom/Equiv/Units/Basic.lean -> Mathlib/Algebra/Group/Units/Equiv.lean renamed: Mathlib/Algebra/Hom/Equiv/Units/GroupWithZero.lean -> Mathlib/Algebra/GroupWithZero/Units/Equiv.lean renamed: Mathlib/Algebra/Hom/Freiman.lean -> Mathlib/Algebra/Group/Freiman.lean renamed: Mathlib/Algebra/Hom/Group/Basic.lean -> Mathlib/Algebra/Group/Hom/Basic.lean renamed: Mathlib/Algebra/Hom/Group/Defs.lean -> Mathlib/Algebra/Group/Hom/Defs.lean renamed: Mathlib/Algebra/Hom/GroupAction.lean -> Mathlib/GroupTheory/GroupAction/Hom.lean renamed: Mathlib/Algebra/Hom/GroupInstances.lean -> Mathlib/Algebra/Group/Hom/Instances.lean renamed: Mathlib/Algebra/Hom/Iterate.lean -> Mathlib/Algebra/GroupPower/IterateHom.lean renamed: Mathlib/Algebra/Hom/Centroid.lean -> Mathlib/Algebra/Ring/CentroidHom.lean renamed: Mathlib/Algebra/Hom/Ring/Basic.lean -> Mathlib/Algebra/Ring/Hom/Basic.lean renamed: Mathlib/Algebra/Hom/Ring/Defs.lean -> Mathlib/Algebra/Ring/Hom/Defs.lean renamed: Mathlib/Algebra/Hom/Units.lean -> Mathlib/Algebra/Group/Units/Hom.lean

Zulip thread: https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Reorganizing.20.60Mathlib.2EAlgebra.2EHom.60

@@ -3,10 +3,10 @@ Copyright (c) 2018 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Chris Hughes, Michael Howes
 -/
+import Mathlib.Algebra.Group.Aut
+import Mathlib.Algebra.Group.Hom.Defs
 import Mathlib.Algebra.Group.Semiconj.Defs
 import Mathlib.Algebra.GroupWithZero.Basic
-import Mathlib.Algebra.Hom.Aut
-import Mathlib.Algebra.Hom.Group.Defs
 
 #align_import algebra.group.conj from "leanprover-community/mathlib"@"0743cc5d9d86bcd1bba10f480e948a257d65056f"
 

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

@@ -6,7 +6,7 @@ Authors: Patrick Massot, Chris Hughes, Michael Howes
 import Mathlib.Algebra.Group.Semiconj.Defs
 import Mathlib.Algebra.GroupWithZero.Basic
 import Mathlib.Algebra.Hom.Aut
-import Mathlib.Algebra.Hom.Group
+import Mathlib.Algebra.Hom.Group.Defs
 
 #align_import algebra.group.conj from "leanprover-community/mathlib"@"0743cc5d9d86bcd1bba10f480e948a257d65056f"
 

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

@@ -3,7 +3,7 @@ Copyright (c) 2018 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Chris Hughes, Michael Howes
 -/
-import Mathlib.Algebra.Group.Semiconj
+import Mathlib.Algebra.Group.Semiconj.Defs
 import Mathlib.Algebra.GroupWithZero.Basic
 import Mathlib.Algebra.Hom.Aut
 import Mathlib.Algebra.Hom.Group

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

This has nice performance benefits.

@@ -49,7 +49,7 @@ theorem IsConj.trans {a b c : α} : IsConj a b → IsConj b c → IsConj a c
 #align is_conj.trans IsConj.trans
 
 @[simp]
-theorem isConj_iff_eq {α : Type _} [CommMonoid α] {a b : α} : IsConj a b ↔ a = b :=
+theorem isConj_iff_eq {α : Type*} [CommMonoid α] {a b : α} : IsConj a b ↔ a = b :=
   ⟨fun ⟨c, hc⟩ => by
     rw [SemiconjBy, mul_comm, ← Units.mul_inv_eq_iff_eq_mul, mul_assoc, c.mul_inv, mul_one] at hc
     exact hc, fun h => by rw [h]⟩
@@ -144,7 +144,7 @@ namespace IsConj
 /- This small quotient API is largely copied from the API of `Associates`;
 where possible, try to keep them in sync -/
 /-- The setoid of the relation `IsConj` iff there is a unit `u` such that `u * x = y * u` -/
-protected def setoid (α : Type _) [Monoid α] : Setoid α where
+protected def setoid (α : Type*) [Monoid α] : Setoid α where
   r := IsConj
   iseqv := ⟨IsConj.refl, IsConj.symm, IsConj.trans⟩
 #align is_conj.setoid IsConj.setoid
@@ -154,7 +154,7 @@ end IsConj
 attribute [local instance] IsConj.setoid
 
 /-- The quotient type of conjugacy classes of a group. -/
-def ConjClasses (α : Type _) [Monoid α] : Type _ :=
+def ConjClasses (α : Type*) [Monoid α] : Type _ :=
   Quotient (IsConj.setoid α)
 #align conj_classes ConjClasses
 
@@ -165,7 +165,7 @@ section Monoid
 variable [Monoid α] [Monoid β]
 
 /-- The canonical quotient map from a monoid `α` into the `ConjClasses` of `α` -/
-protected def mk {α : Type _} [Monoid α] (a : α) : ConjClasses α := ⟦a⟧
+protected def mk {α : Type*} [Monoid α] (a : α) : ConjClasses α := ⟦a⟧
 #align conj_classes.mk ConjClasses.mk
 
 instance : Inhabited (ConjClasses α) := ⟨⟦1⟧⟩

• depends on: #5966

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

@@ -2,17 +2,14 @@
 Copyright (c) 2018 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Chris Hughes, Michael Howes
-
-! This file was ported from Lean 3 source module algebra.group.conj
-! leanprover-community/mathlib commit 0743cc5d9d86bcd1bba10f480e948a257d65056f
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Group.Semiconj
 import Mathlib.Algebra.GroupWithZero.Basic
 import Mathlib.Algebra.Hom.Aut
 import Mathlib.Algebra.Hom.Group
 
+#align_import algebra.group.conj from "leanprover-community/mathlib"@"0743cc5d9d86bcd1bba10f480e948a257d65056f"
+
 /-!
 # Conjugacy of group elements
 

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

@@ -144,7 +144,7 @@ theorem isConj_iff₀ [GroupWithZero α] {a b : α} : IsConj a b ↔ ∃ c : α,
 
 namespace IsConj
 
-/- This small quotient API is largely copied from the API of `associates`;
+/- This small quotient API is largely copied from the API of `Associates`;
 where possible, try to keep them in sync -/
 /-- The setoid of the relation `IsConj` iff there is a unit `u` such that `u * x = y * u` -/
 protected def setoid (α : Type _) [Monoid α] : Setoid α where
@@ -235,7 +235,7 @@ Since `Multiset` and `Con.quotient` are both quotient types, unification will ch
 that the relations `List.perm` and `c.toSetoid.r` unify. However, `c.toSetoid` depends on
 a `Mul M` instance, so this unification triggers a search for `Mul (List α)`;
 this will traverse all subclasses of `Mul` before failing.
-On the other hand, the search for an instance of `DecidableEq (Con.quotient c)` for `c : con M`
+On the other hand, the search for an instance of `DecidableEq (Con.quotient c)` for `c : Con M`
 can quickly reject the candidate instance `Multiset.decidableEq` because the type of
 `List.perm : List ?m_1 → List ?m_1 → Prop` does not unify with `M → M → Prop`.
 Therefore, we should assign `Con.quotient.decidableEq` a lower priority because it fails slowly.

@@ -332,5 +332,4 @@ theorem carrier_eq_preimage_mk {a : ConjClasses α} : a.carrier = ConjClasses.mk
 
 end ConjClasses
 
--- porting notes: not implemented
--- assert_not_exists multiset
+assert_not_exists Multiset

This was done semi-automatically with some regular expressions in vim in contrast to the fully automatic https://github.com/leanprover-community/mathlib4/pull/1523.

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

@@ -317,8 +317,8 @@ theorem mem_carrier_mk {a : α} : a ∈ carrier (ConjClasses.mk a) :=
   IsConj.refl _
 #align conj_classes.mem_carrier_mk ConjClasses.mem_carrier_mk
 
-theorem mem_carrier_iff_mk_eq {a : α} {b : ConjClasses α} : a ∈ carrier b ↔ ConjClasses.mk a = b :=
-  by
+theorem mem_carrier_iff_mk_eq {a : α} {b : ConjClasses α} :
+    a ∈ carrier b ↔ ConjClasses.mk a = b := by
   revert b
   rw [forall_isConj]
   intro b

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>

@@ -231,17 +231,17 @@ If those conditions hold, the instance `instT` should be assigned lower priority
 
 For example, suppose the search for an instance of `DecidableEq (Multiset α)` tries the
 candidate instance `Con.quotient.decidableEq (c : Con M) : decidableEq c.quotient`.
-Since `Multiset` and `con.quotient` are both quotient types, unification will check
+Since `Multiset` and `Con.quotient` are both quotient types, unification will check
 that the relations `List.perm` and `c.toSetoid.r` unify. However, `c.toSetoid` depends on
 a `Mul M` instance, so this unification triggers a search for `Mul (List α)`;
 this will traverse all subclasses of `Mul` before failing.
-On the other hand, the search for an instance of `decidableEq (con.quotient c)` for `c : con M`
-can quickly reject the candidate instance `Multiset.has_decidableEq` because the type of
+On the other hand, the search for an instance of `DecidableEq (Con.quotient c)` for `c : con M`
+can quickly reject the candidate instance `Multiset.decidableEq` because the type of
 `List.perm : List ?m_1 → List ?m_1 → Prop` does not unify with `M → M → Prop`.
 Therefore, we should assign `Con.quotient.decidableEq` a lower priority because it fails slowly.
-(In terms of the rules above, `C := decidableEq`, `T := Con.quotient`,
+(In terms of the rules above, `C := DecidableEq`, `T := Con.quotient`,
 `instT := Con.quotient.decidableEq`, `T' := Multiset`, `instT' := Multiset.decidableEq`,
-and `S := quot`.)
+and `S := Quot`.)
 
 If the type involved is a free variable (rather than an instantiation of some type `S`),
 the instance priority should be even lower, see Note [lower instance priority].

Port of algebra.group.conj

Based on 0743cc5d

Co-authored-by: Jon Eugster <eugster.jon@gmail.com>