algebra.hom.equiv.basic | Mathlib porting status

(last sync)

chore(*): fix @[to_additive, simp] to the correct order (#19169)

Whilst making some files, I noticed that there is some lemmas that have the wrong order for to_additive and simp.

Diff

@@ -309,10 +309,10 @@ fun_like.ext _ _ e.apply_symm_apply
 theorem self_trans_symm (e : M ≃* N) : e.trans e.symm = refl M :=
 fun_like.ext _ _ e.symm_apply_apply
 
-@[to_additive, simp] lemma coe_monoid_hom_refl {M} [mul_one_class M] :
+@[simp, to_additive] lemma coe_monoid_hom_refl {M} [mul_one_class M] :
   (refl M : M →* M) = monoid_hom.id M := rfl
 
-@[to_additive, simp] lemma coe_monoid_hom_trans {M N P}
+@[simp, to_additive] lemma coe_monoid_hom_trans {M N P}
   [mul_one_class M] [mul_one_class N] [mul_one_class P] (e₁ : M ≃* N) (e₂ : N ≃* P) :
   (e₁.trans e₂ : M →* P) = (e₂ : N →* P).comp ↑e₁ :=
 rfl

(no changes)

e753057a

feat(algebra/hom/equiv/basic): Add to_additive to Pi_congr_right lemmas (#17827)

Add to_additive attribute to three lemmas about mul_equiv.Pi_congr_right.

Diff

@@ -450,16 +450,16 @@ def Pi_congr_right {η : Type*}
   map_mul' := λ x y, funext $ λ j, (es j).map_mul (x j) (y j),
   .. equiv.Pi_congr_right (λ j, (es j).to_equiv) }
 
-@[simp]
+@[simp, to_additive]
 lemma Pi_congr_right_refl {η : Type*} {Ms : η → Type*} [Π j, has_mul (Ms j)] :
   Pi_congr_right (λ j, mul_equiv.refl (Ms j)) = mul_equiv.refl _ := rfl
 
-@[simp]
+@[simp, to_additive]
 lemma Pi_congr_right_symm {η : Type*}
   {Ms Ns : η → Type*} [Π j, has_mul (Ms j)] [Π j, has_mul (Ns j)]
   (es : ∀ j, Ms j ≃* Ns j) : (Pi_congr_right es).symm = (Pi_congr_right $ λ i, (es i).symm) := rfl
 
-@[simp]
+@[simp, to_additive]
 lemma Pi_congr_right_trans {η : Type*}
   {Ms Ns Ps : η → Type*} [Π j, has_mul (Ms j)] [Π j, has_mul (Ns j)]
   [Π j, has_mul (Ps j)]

(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

@@ -3,10 +3,10 @@ Copyright (c) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
 -/
-import Algebra.Hom.Group
+import Algebra.Group.Hom.Defs
 import Data.FunLike.Equiv
 import Logic.Equiv.Basic
-import Data.Pi.Algebra
+import Algebra.Group.Pi.Basic
 
 #align_import algebra.hom.equiv.basic from "leanprover-community/mathlib"@"1ac8d4304efba9d03fa720d06516fac845aa5353"

bump to nightly-2024-01-19-06

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

33b57512

Diff

@@ -125,7 +125,7 @@ variable (F)
 instance (priority := 100) [Mul M] [Mul N] [h : MulEquivClass F M N] : MulHomClass F M N :=
   { h with
     coe := (coe : F → M → N)
-    coe_injective' := @FunLike.coe_injective F _ _ _ }
+    coe_injective' := @DFunLike.coe_injective F _ _ _ }
 
 -- See note [lower instance priority]
 @[to_additive]
@@ -531,7 +531,7 @@ theorem symm_comp_eq {α : Type _} (e : M ≃* N) (f : α → M) (g : α → N)
 #print MulEquiv.symm_trans_self /-
 @[simp, to_additive]
 theorem symm_trans_self (e : M ≃* N) : e.symm.trans e = refl N :=
-  FunLike.ext _ _ e.apply_symm_apply
+  DFunLike.ext _ _ e.apply_symm_apply
 #align mul_equiv.symm_trans_self MulEquiv.symm_trans_self
 #align add_equiv.symm_trans_self AddEquiv.symm_trans_self
 -/
@@ -539,7 +539,7 @@ theorem symm_trans_self (e : M ≃* N) : e.symm.trans e = refl N :=
 #print MulEquiv.self_trans_symm /-
 @[simp, to_additive]
 theorem self_trans_symm (e : M ≃* N) : e.trans e.symm = refl M :=
-  FunLike.ext _ _ e.symm_apply_apply
+  DFunLike.ext _ _ e.symm_apply_apply
 #align mul_equiv.self_trans_symm MulEquiv.self_trans_symm
 #align add_equiv.self_trans_symm AddEquiv.self_trans_symm
 -/
@@ -568,7 +568,7 @@ theorem coe_monoidHom_trans {M N P} [MulOneClass M] [MulOneClass N] [MulOneClass
   to_additive
       "Two additive isomorphisms agree if they are defined by the same underlying function."]
 theorem ext {f g : MulEquiv M N} (h : ∀ x, f x = g x) : f = g :=
-  FunLike.ext f g h
+  DFunLike.ext f g h
 #align mul_equiv.ext MulEquiv.ext
 #align add_equiv.ext AddEquiv.ext
 -/
@@ -576,7 +576,7 @@ theorem ext {f g : MulEquiv M N} (h : ∀ x, f x = g x) : f = g :=
 #print MulEquiv.ext_iff /-
 @[to_additive]
 theorem ext_iff {f g : MulEquiv M N} : f = g ↔ ∀ x, f x = g x :=
-  FunLike.ext_iff
+  DFunLike.ext_iff
 #align mul_equiv.ext_iff MulEquiv.ext_iff
 #align add_equiv.ext_iff AddEquiv.ext_iff
 -/
@@ -600,7 +600,7 @@ theorem mk_coe' (e : M ≃* N) (f h₁ h₂ h₃) : (MulEquiv.mk f (⇑e) h₁ h
 #print MulEquiv.congr_arg /-
 @[to_additive]
 protected theorem congr_arg {f : MulEquiv M N} {x x' : M} : x = x' → f x = f x' :=
-  FunLike.congr_arg f
+  DFunLike.congr_arg f
 #align mul_equiv.congr_arg MulEquiv.congr_arg
 #align add_equiv.congr_arg AddEquiv.congr_arg
 -/
@@ -608,7 +608,7 @@ protected theorem congr_arg {f : MulEquiv M N} {x x' : M} : x = x' → f x = f x
 #print MulEquiv.congr_fun /-
 @[to_additive]
 protected theorem congr_fun {f g : MulEquiv M N} (h : f = g) (x : M) : f x = g x :=
-  FunLike.congr_fun h x
+  DFunLike.congr_fun h x
 #align mul_equiv.congr_fun MulEquiv.congr_fun
 #align add_equiv.congr_fun AddEquiv.congr_fun
 -/

bump to nightly-2023-11-15-06

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

38c8ceef

Diff

@@ -797,17 +797,17 @@ theorem piCongrRight_trans {η : Type _} {Ms Ns Ps : η → Type _} [∀ j, Mul
 #align add_equiv.Pi_congr_right_trans AddEquiv.piCongrRight_trans
 -/
 
-#print MulEquiv.piSubsingleton /-
+#print MulEquiv.piUnique /-
 /-- A family indexed by a nonempty subsingleton type is equivalent to the element at the single
 index. -/
-@[to_additive AddEquiv.piSubsingleton
+@[to_additive AddEquiv.piUnique
       "A family indexed by a nonempty subsingleton type is\nequivalent to the element at the single index.",
   simps]
-def piSubsingleton {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)] [Subsingleton ι] (i : ι) :
+def piUnique {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)] [Subsingleton ι] (i : ι) :
     (∀ j, M j) ≃* M i :=
   { Equiv.piSubsingleton M i with map_mul' := fun f1 f2 => Pi.mul_apply _ _ _ }
-#align mul_equiv.Pi_subsingleton MulEquiv.piSubsingleton
-#align add_equiv.Pi_subsingleton AddEquiv.piSubsingleton
+#align mul_equiv.Pi_subsingleton MulEquiv.piUnique
+#align add_equiv.Pi_subsingleton AddEquiv.piUnique
 -/
 
 /-!

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,10 +3,10 @@ Copyright (c) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
 -/
-import Mathbin.Algebra.Hom.Group
-import Mathbin.Data.FunLike.Equiv
-import Mathbin.Logic.Equiv.Basic
-import Mathbin.Data.Pi.Algebra
+import Algebra.Hom.Group
+import Data.FunLike.Equiv
+import Logic.Equiv.Basic
+import Data.Pi.Algebra
 
 #align_import algebra.hom.equiv.basic from "leanprover-community/mathlib"@"1ac8d4304efba9d03fa720d06516fac845aa5353"

bump to nightly-2023-08-17-09

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

60285dcc

Diff

@@ -107,7 +107,7 @@ add_decl_doc MulEquiv.toMulHom
 You should extend this class when you extend `mul_equiv`. -/
 @[to_additive]
 class MulEquivClass (F A B : Type _) [Mul A] [Mul B] extends EquivLike F A B where
-  map_mul : ∀ (f : F) (a b), f (a * b) = f a * f b
+  map_hMul : ∀ (f : F) (a b), f (a * b) = f a * f b
 #align mul_equiv_class MulEquivClass
 #align add_equiv_class AddEquivClass
 -/
@@ -197,7 +197,7 @@ instance [Mul M] [Mul N] : MulEquivClass (M ≃* N) M N
   left_inv := left_inv
   right_inv := right_inv
   coe_injective' f g h₁ h₂ := by cases f; cases g; congr
-  map_mul := map_mul'
+  map_hMul := map_mul'
 
 variable [Mul M] [Mul N] [Mul P] [Mul Q]
 
@@ -291,7 +291,7 @@ instance : Inhabited (M ≃* M) :=
 @[symm, to_additive "The inverse of an isomorphism is an isomorphism."]
 def symm (h : M ≃* N) : N ≃* M :=
   { h.toEquiv.symm with
-    map_mul' := (h.toMulHom.inverse h.toEquiv.symm h.left_inv h.right_inv).map_mul }
+    map_mul' := (h.toMulHom.inverse h.toEquiv.symm h.left_inv h.right_inv).map_hMul }
 #align mul_equiv.symm MulEquiv.symm
 #align add_equiv.symm AddEquiv.symm
 -/
@@ -764,7 +764,7 @@ def piCongrRight {η : Type _} {Ms Ns : η → Type _} [∀ j, Mul (Ms j)] [∀
       (es j).toEquiv with
     toFun := fun x j => es j (x j)
     invFun := fun x j => (es j).symm (x j)
-    map_mul' := fun x y => funext fun j => (es j).map_mul (x j) (y j) }
+    map_mul' := fun x y => funext fun j => (es j).map_hMul (x j) (y j) }
 #align mul_equiv.Pi_congr_right MulEquiv.piCongrRight
 #align add_equiv.Pi_congr_right AddEquiv.piCongrRight
 -/
@@ -851,7 +851,7 @@ def MulHom.toMulEquiv [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M) (h₁
   invFun := g
   left_inv := MulHom.congr_fun h₁
   right_inv := MulHom.congr_fun h₂
-  map_mul' := f.map_mul
+  map_mul' := f.map_hMul
 #align mul_hom.to_mul_equiv MulHom.toMulEquiv
 #align add_hom.to_add_equiv AddHom.toAddEquiv
 -/
@@ -870,7 +870,7 @@ def MonoidHom.toMulEquiv [MulOneClass M] [MulOneClass N] (f : M →* N) (g : N 
   invFun := g
   left_inv := MonoidHom.congr_fun h₁
   right_inv := MonoidHom.congr_fun h₂
-  map_mul' := f.map_mul
+  map_mul' := f.map_hMul
 #align monoid_hom.to_mul_equiv MonoidHom.toMulEquiv
 #align add_monoid_hom.to_add_equiv AddMonoidHom.toAddEquiv
 -/

bump to nightly-2023-08-11-09

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

0d5a6584

Diff

@@ -213,7 +213,7 @@ theorem toEquiv_eq_coe (f : M ≃* N) : f.toEquiv = f :=
 theorem toFun_eq_coe {f : M ≃* N} : f.toFun = f :=
   rfl
 #align mul_equiv.to_fun_eq_coe MulEquiv.toFun_eq_coe
-#align add_equiv.to_fun_eq_coe AddEquiv.toFun_eq_coe
+#align add_equiv.to_fun_eq_coe AddEquiv.to_fun_eq_coe
 
 #print MulEquiv.coe_toEquiv /-
 @[simp, to_additive]

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
-
-! This file was ported from Lean 3 source module algebra.hom.equiv.basic
-! leanprover-community/mathlib commit 1ac8d4304efba9d03fa720d06516fac845aa5353
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Hom.Group
 import Mathbin.Data.FunLike.Equiv
 import Mathbin.Logic.Equiv.Basic
 import Mathbin.Data.Pi.Algebra
 
+#align_import algebra.hom.equiv.basic from "leanprover-community/mathlib"@"1ac8d4304efba9d03fa720d06516fac845aa5353"
+
 /-!
 # Multiplicative and additive equivs

bump to nightly-2023-06-15-03

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

9867a146

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module algebra.hom.equiv.basic
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
+! leanprover-community/mathlib commit 1ac8d4304efba9d03fa720d06516fac845aa5353
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -548,7 +548,7 @@ theorem self_trans_symm (e : M ≃* N) : e.trans e.symm = refl M :=
 -/
 
 #print MulEquiv.coe_monoidHom_refl /-
-@[to_additive, simp]
+@[simp, to_additive]
 theorem coe_monoidHom_refl {M} [MulOneClass M] : (refl M : M →* M) = MonoidHom.id M :=
   rfl
 #align mul_equiv.coe_monoid_hom_refl MulEquiv.coe_monoidHom_refl
@@ -556,7 +556,7 @@ theorem coe_monoidHom_refl {M} [MulOneClass M] : (refl M : M →* M) = MonoidHom
 -/
 
 #print MulEquiv.coe_monoidHom_trans /-
-@[to_additive, simp]
+@[simp, to_additive]
 theorem coe_monoidHom_trans {M N P} [MulOneClass M] [MulOneClass N] [MulOneClass P] (e₁ : M ≃* N)
     (e₂ : N ≃* P) : (e₁.trans e₂ : M →* P) = (e₂ : N →* P).comp ↑e₁ :=
   rfl

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -59,6 +59,7 @@ def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M) (h₁ : Funct
 #align add_hom.inverse AddHom.inverse
 -/
 
+#print MonoidHom.inverse /-
 /-- The inverse of a bijective `monoid_hom` is a `monoid_hom`. -/
 @[to_additive "The inverse of a bijective `add_monoid_hom` is an `add_monoid_hom`.", simps]
 def MonoidHom.inverse {A B : Type _} [Monoid A] [Monoid B] (f : A →* B) (g : B → A)
@@ -68,6 +69,7 @@ def MonoidHom.inverse {A B : Type _} [Monoid A] [Monoid B] (f : A →* B) (g : B
     map_one' := by rw [← f.map_one, h₁] }
 #align monoid_hom.inverse MonoidHom.inverse
 #align add_monoid_hom.inverse AddMonoidHom.inverse
+-/
 
 #print AddEquiv /-
 /-- add_equiv α β is the type of an equiv α ≃ β which preserves addition. -/
@@ -113,10 +115,8 @@ class MulEquivClass (F A B : Type _) [Mul A] [Mul B] extends EquivLike F A B whe
 #align add_equiv_class AddEquivClass
 -/
 
--- mathport name: «expr ≃* »
 infixl:25 " ≃* " => MulEquiv
 
--- mathport name: «expr ≃+ »
 infixl:25 " ≃+ " => AddEquiv
 
 namespace MulEquivClass
@@ -143,6 +143,7 @@ instance (priority := 100) [MulOneClass M] [MulOneClass N] [MulEquivClass F M N]
         _ = e (inv e (1 : N)) := by rw [← map_mul, one_mul]
         _ = 1 := right_inv e 1 }
 
+#print MulEquivClass.toMonoidWithZeroHomClass /-
 -- See note [lower instance priority]
 instance (priority := 100) toMonoidWithZeroHomClass {α β : Type _} [MulZeroOneClass α]
     [MulZeroOneClass β] [MulEquivClass F α β] : MonoidWithZeroHomClass F α β :=
@@ -152,22 +153,27 @@ instance (priority := 100) toMonoidWithZeroHomClass {α β : Type _} [MulZeroOne
         e 0 = e 0 * e (EquivLike.inv e 0) := by rw [← map_mul, MulZeroClass.zero_mul]
         _ = 0 := by convert MulZeroClass.mul_zero _; exact EquivLike.right_inv e _ }
 #align mul_equiv_class.to_monoid_with_zero_hom_class MulEquivClass.toMonoidWithZeroHomClass
+-/
 
 variable {F}
 
+#print MulEquivClass.map_eq_one_iff /-
 @[simp, to_additive]
 theorem map_eq_one_iff {M N} [MulOneClass M] [MulOneClass N] [MulEquivClass F M N] (h : F) {x : M} :
     h x = 1 ↔ x = 1 :=
   map_eq_one_iff h (EquivLike.injective h)
 #align mul_equiv_class.map_eq_one_iff MulEquivClass.map_eq_one_iff
 #align add_equiv_class.map_eq_zero_iff AddEquivClass.map_eq_zero_iff
+-/
 
+#print MulEquivClass.map_ne_one_iff /-
 @[to_additive]
 theorem map_ne_one_iff {M N} [MulOneClass M] [MulOneClass N] [MulEquivClass F M N] (h : F) {x : M} :
     h x ≠ 1 ↔ x ≠ 1 :=
   map_ne_one_iff h (EquivLike.injective h)
 #align mul_equiv_class.map_ne_one_iff MulEquivClass.map_ne_one_iff
 #align add_equiv_class.map_ne_zero_iff AddEquivClass.map_ne_zero_iff
+-/
 
 end MulEquivClass
 
@@ -198,11 +204,13 @@ instance [Mul M] [Mul N] : MulEquivClass (M ≃* N) M N
 
 variable [Mul M] [Mul N] [Mul P] [Mul Q]
 
+#print MulEquiv.toEquiv_eq_coe /-
 @[simp, to_additive]
 theorem toEquiv_eq_coe (f : M ≃* N) : f.toEquiv = f :=
   rfl
 #align mul_equiv.to_equiv_eq_coe MulEquiv.toEquiv_eq_coe
 #align add_equiv.to_equiv_eq_coe AddEquiv.toEquiv_eq_coe
+-/
 
 @[simp, to_additive]
 theorem toFun_eq_coe {f : M ≃* N} : f.toFun = f :=
@@ -210,24 +218,30 @@ theorem toFun_eq_coe {f : M ≃* N} : f.toFun = f :=
 #align mul_equiv.to_fun_eq_coe MulEquiv.toFun_eq_coe
 #align add_equiv.to_fun_eq_coe AddEquiv.toFun_eq_coe
 
+#print MulEquiv.coe_toEquiv /-
 @[simp, to_additive]
 theorem coe_toEquiv {f : M ≃* N} : ⇑(f : M ≃ N) = f :=
   rfl
 #align mul_equiv.coe_to_equiv MulEquiv.coe_toEquiv
 #align add_equiv.coe_to_equiv AddEquiv.coe_toEquiv
+-/
 
+#print MulEquiv.coe_toMulHom /-
 @[simp, to_additive]
 theorem coe_toMulHom {f : M ≃* N} : ⇑f.toMulHom = f :=
   rfl
 #align mul_equiv.coe_to_mul_hom MulEquiv.coe_toMulHom
 #align add_equiv.coe_to_add_hom AddEquiv.coe_toAddHom
+-/
 
+#print MulEquiv.map_mul /-
 /-- A multiplicative isomorphism preserves multiplication. -/
 @[to_additive "An additive isomorphism preserves addition."]
 protected theorem map_mul (f : M ≃* N) : ∀ x y, f (x * y) = f x * f y :=
   map_mul f
 #align mul_equiv.map_mul MulEquiv.map_mul
 #align add_equiv.map_add AddEquiv.map_add
+-/
 
 #print MulEquiv.mk' /-
 /-- Makes a multiplicative isomorphism from a bijection which preserves multiplication. -/
@@ -238,23 +252,29 @@ def mk' (f : M ≃ N) (h : ∀ x y, f (x * y) = f x * f y) : M ≃* N :=
 #align add_equiv.mk' AddEquiv.mk'
 -/
 
+#print MulEquiv.bijective /-
 @[to_additive]
 protected theorem bijective (e : M ≃* N) : Function.Bijective e :=
   EquivLike.bijective e
 #align mul_equiv.bijective MulEquiv.bijective
 #align add_equiv.bijective AddEquiv.bijective
+-/
 
+#print MulEquiv.injective /-
 @[to_additive]
 protected theorem injective (e : M ≃* N) : Function.Injective e :=
   EquivLike.injective e
 #align mul_equiv.injective MulEquiv.injective
 #align add_equiv.injective AddEquiv.injective
+-/
 
+#print MulEquiv.surjective /-
 @[to_additive]
 protected theorem surjective (e : M ≃* N) : Function.Surjective e :=
   EquivLike.surjective e
 #align mul_equiv.surjective MulEquiv.surjective
 #align add_equiv.surjective AddEquiv.surjective
+-/
 
 #print MulEquiv.refl /-
 /-- The identity map is a multiplicative isomorphism. -/
@@ -279,11 +299,13 @@ def symm (h : M ≃* N) : N ≃* M :=
 #align add_equiv.symm AddEquiv.symm
 -/
 
+#print MulEquiv.invFun_eq_symm /-
 @[simp, to_additive]
 theorem invFun_eq_symm {f : M ≃* N} : f.invFun = f.symm :=
   rfl
 #align mul_equiv.inv_fun_eq_symm MulEquiv.invFun_eq_symm
 #align add_equiv.neg_fun_eq_symm AddEquiv.invFun_eq_symm
+-/
 
 #print MulEquiv.Simps.symm_apply /-
 -- we don't hyperlink the note in the additive version, since that breaks syntax highlighting
@@ -300,11 +322,13 @@ initialize_simps_projections AddEquiv (toFun → apply, invFun → symm_apply)
 
 initialize_simps_projections MulEquiv (toFun → apply, invFun → symm_apply)
 
+#print MulEquiv.toEquiv_symm /-
 @[simp, to_additive]
 theorem toEquiv_symm (f : M ≃* N) : f.symm.toEquiv = f.toEquiv.symm :=
   rfl
 #align mul_equiv.to_equiv_symm MulEquiv.toEquiv_symm
 #align add_equiv.to_equiv_symm AddEquiv.toEquiv_symm
+-/
 
 @[simp, to_additive]
 theorem coe_mk (f : M → N) (g h₁ h₂ h₃) : ⇑(MulEquiv.mk f g h₁ h₂ h₃) = f :=
@@ -319,17 +343,21 @@ theorem toEquiv_mk (f : M → N) (g : N → M) (h₁ h₂ h₃) :
 #align mul_equiv.to_equiv_mk MulEquiv.toEquiv_mk
 #align add_equiv.to_equiv_mk AddEquiv.to_equiv_mk
 
+#print MulEquiv.symm_symm /-
 @[simp, to_additive]
 theorem symm_symm : ∀ f : M ≃* N, f.symm.symm = f
   | ⟨f, g, h₁, h₂, h₃⟩ => rfl
 #align mul_equiv.symm_symm MulEquiv.symm_symm
 #align add_equiv.symm_symm AddEquiv.symm_symm
+-/
 
+#print MulEquiv.symm_bijective /-
 @[to_additive]
 theorem symm_bijective : Function.Bijective (symm : M ≃* N → N ≃* M) :=
   Equiv.bijective ⟨symm, symm, symm_symm, symm_symm⟩
 #align mul_equiv.symm_bijective MulEquiv.symm_bijective
 #align add_equiv.symm_bijective AddEquiv.symm_bijective
+-/
 
 @[simp, to_additive]
 theorem symm_mk (f : M → N) (g h₁ h₂ h₃) :
@@ -360,140 +388,183 @@ def trans (h1 : M ≃* N) (h2 : N ≃* P) : M ≃* P :=
 #align add_equiv.trans AddEquiv.trans
 -/
 
+#print MulEquiv.apply_symm_apply /-
 /-- `e.symm` is a right inverse of `e`, written as `e (e.symm y) = y`. -/
 @[simp, to_additive "`e.symm` is a right inverse of `e`, written as `e (e.symm y) = y`."]
 theorem apply_symm_apply (e : M ≃* N) (y : N) : e (e.symm y) = y :=
   e.toEquiv.apply_symm_apply y
 #align mul_equiv.apply_symm_apply MulEquiv.apply_symm_apply
 #align add_equiv.apply_symm_apply AddEquiv.apply_symm_apply
+-/
 
+#print MulEquiv.symm_apply_apply /-
 /-- `e.symm` is a left inverse of `e`, written as `e.symm (e y) = y`. -/
 @[simp, to_additive "`e.symm` is a left inverse of `e`, written as `e.symm (e y) = y`."]
 theorem symm_apply_apply (e : M ≃* N) (x : M) : e.symm (e x) = x :=
   e.toEquiv.symm_apply_apply x
 #align mul_equiv.symm_apply_apply MulEquiv.symm_apply_apply
 #align add_equiv.symm_apply_apply AddEquiv.symm_apply_apply
+-/
 
+#print MulEquiv.symm_comp_self /-
 @[simp, to_additive]
 theorem symm_comp_self (e : M ≃* N) : e.symm ∘ e = id :=
   funext e.symm_apply_apply
 #align mul_equiv.symm_comp_self MulEquiv.symm_comp_self
 #align add_equiv.symm_comp_self AddEquiv.symm_comp_self
+-/
 
+#print MulEquiv.self_comp_symm /-
 @[simp, to_additive]
 theorem self_comp_symm (e : M ≃* N) : e ∘ e.symm = id :=
   funext e.apply_symm_apply
 #align mul_equiv.self_comp_symm MulEquiv.self_comp_symm
 #align add_equiv.self_comp_symm AddEquiv.self_comp_symm
+-/
 
+#print MulEquiv.coe_refl /-
 @[simp, to_additive]
 theorem coe_refl : ⇑(refl M) = id :=
   rfl
 #align mul_equiv.coe_refl MulEquiv.coe_refl
 #align add_equiv.coe_refl AddEquiv.coe_refl
+-/
 
+#print MulEquiv.refl_apply /-
 @[simp, to_additive]
 theorem refl_apply (m : M) : refl M m = m :=
   rfl
 #align mul_equiv.refl_apply MulEquiv.refl_apply
 #align add_equiv.refl_apply AddEquiv.refl_apply
+-/
 
+#print MulEquiv.coe_trans /-
 @[simp, to_additive]
 theorem coe_trans (e₁ : M ≃* N) (e₂ : N ≃* P) : ⇑(e₁.trans e₂) = e₂ ∘ e₁ :=
   rfl
 #align mul_equiv.coe_trans MulEquiv.coe_trans
 #align add_equiv.coe_trans AddEquiv.coe_trans
+-/
 
+#print MulEquiv.trans_apply /-
 @[simp, to_additive]
 theorem trans_apply (e₁ : M ≃* N) (e₂ : N ≃* P) (m : M) : e₁.trans e₂ m = e₂ (e₁ m) :=
   rfl
 #align mul_equiv.trans_apply MulEquiv.trans_apply
 #align add_equiv.trans_apply AddEquiv.trans_apply
+-/
 
+#print MulEquiv.symm_trans_apply /-
 @[simp, to_additive]
 theorem symm_trans_apply (e₁ : M ≃* N) (e₂ : N ≃* P) (p : P) :
     (e₁.trans e₂).symm p = e₁.symm (e₂.symm p) :=
   rfl
 #align mul_equiv.symm_trans_apply MulEquiv.symm_trans_apply
 #align add_equiv.symm_trans_apply AddEquiv.symm_trans_apply
+-/
 
+#print MulEquiv.apply_eq_iff_eq /-
 @[simp, to_additive]
 theorem apply_eq_iff_eq (e : M ≃* N) {x y : M} : e x = e y ↔ x = y :=
   e.Injective.eq_iff
 #align mul_equiv.apply_eq_iff_eq MulEquiv.apply_eq_iff_eq
 #align add_equiv.apply_eq_iff_eq AddEquiv.apply_eq_iff_eq
+-/
 
+#print MulEquiv.apply_eq_iff_symm_apply /-
 @[to_additive]
 theorem apply_eq_iff_symm_apply (e : M ≃* N) {x : M} {y : N} : e x = y ↔ x = e.symm y :=
   e.toEquiv.apply_eq_iff_eq_symm_apply
 #align mul_equiv.apply_eq_iff_symm_apply MulEquiv.apply_eq_iff_symm_apply
 #align add_equiv.apply_eq_iff_symm_apply AddEquiv.apply_eq_iff_symm_apply
+-/
 
+#print MulEquiv.symm_apply_eq /-
 @[to_additive]
 theorem symm_apply_eq (e : M ≃* N) {x y} : e.symm x = y ↔ x = e y :=
   e.toEquiv.symm_apply_eq
 #align mul_equiv.symm_apply_eq MulEquiv.symm_apply_eq
 #align add_equiv.symm_apply_eq AddEquiv.symm_apply_eq
+-/
 
+#print MulEquiv.eq_symm_apply /-
 @[to_additive]
 theorem eq_symm_apply (e : M ≃* N) {x y} : y = e.symm x ↔ e y = x :=
   e.toEquiv.eq_symm_apply
 #align mul_equiv.eq_symm_apply MulEquiv.eq_symm_apply
 #align add_equiv.eq_symm_apply AddEquiv.eq_symm_apply
+-/
 
+#print MulEquiv.eq_comp_symm /-
 @[to_additive]
 theorem eq_comp_symm {α : Type _} (e : M ≃* N) (f : N → α) (g : M → α) :
     f = g ∘ e.symm ↔ f ∘ e = g :=
   e.toEquiv.eq_comp_symm f g
 #align mul_equiv.eq_comp_symm MulEquiv.eq_comp_symm
 #align add_equiv.eq_comp_symm AddEquiv.eq_comp_symm
+-/
 
+#print MulEquiv.comp_symm_eq /-
 @[to_additive]
 theorem comp_symm_eq {α : Type _} (e : M ≃* N) (f : N → α) (g : M → α) :
     g ∘ e.symm = f ↔ g = f ∘ e :=
   e.toEquiv.comp_symm_eq f g
 #align mul_equiv.comp_symm_eq MulEquiv.comp_symm_eq
 #align add_equiv.comp_symm_eq AddEquiv.comp_symm_eq
+-/
 
+#print MulEquiv.eq_symm_comp /-
 @[to_additive]
 theorem eq_symm_comp {α : Type _} (e : M ≃* N) (f : α → M) (g : α → N) :
     f = e.symm ∘ g ↔ e ∘ f = g :=
   e.toEquiv.eq_symm_comp f g
 #align mul_equiv.eq_symm_comp MulEquiv.eq_symm_comp
 #align add_equiv.eq_symm_comp AddEquiv.eq_symm_comp
+-/
 
+#print MulEquiv.symm_comp_eq /-
 @[to_additive]
 theorem symm_comp_eq {α : Type _} (e : M ≃* N) (f : α → M) (g : α → N) :
     e.symm ∘ g = f ↔ g = e ∘ f :=
   e.toEquiv.symm_comp_eq f g
 #align mul_equiv.symm_comp_eq MulEquiv.symm_comp_eq
 #align add_equiv.symm_comp_eq AddEquiv.symm_comp_eq
+-/
 
+#print MulEquiv.symm_trans_self /-
 @[simp, to_additive]
 theorem symm_trans_self (e : M ≃* N) : e.symm.trans e = refl N :=
   FunLike.ext _ _ e.apply_symm_apply
 #align mul_equiv.symm_trans_self MulEquiv.symm_trans_self
 #align add_equiv.symm_trans_self AddEquiv.symm_trans_self
+-/
 
+#print MulEquiv.self_trans_symm /-
 @[simp, to_additive]
 theorem self_trans_symm (e : M ≃* N) : e.trans e.symm = refl M :=
   FunLike.ext _ _ e.symm_apply_apply
 #align mul_equiv.self_trans_symm MulEquiv.self_trans_symm
 #align add_equiv.self_trans_symm AddEquiv.self_trans_symm
+-/
 
+#print MulEquiv.coe_monoidHom_refl /-
 @[to_additive, simp]
 theorem coe_monoidHom_refl {M} [MulOneClass M] : (refl M : M →* M) = MonoidHom.id M :=
   rfl
 #align mul_equiv.coe_monoid_hom_refl MulEquiv.coe_monoidHom_refl
 #align add_equiv.coe_add_monoid_hom_refl AddEquiv.coe_addMonoidHom_refl
+-/
 
+#print MulEquiv.coe_monoidHom_trans /-
 @[to_additive, simp]
 theorem coe_monoidHom_trans {M N P} [MulOneClass M] [MulOneClass N] [MulOneClass P] (e₁ : M ≃* N)
     (e₂ : N ≃* P) : (e₁.trans e₂ : M →* P) = (e₂ : N →* P).comp ↑e₁ :=
   rfl
 #align mul_equiv.coe_monoid_hom_trans MulEquiv.coe_monoidHom_trans
 #align add_equiv.coe_add_monoid_hom_trans AddEquiv.coe_addMonoidHom_trans
+-/
 
+#print MulEquiv.ext /-
 /-- Two multiplicative isomorphisms agree if they are defined by the
     same underlying function. -/
 @[ext,
@@ -503,36 +574,47 @@ theorem ext {f g : MulEquiv M N} (h : ∀ x, f x = g x) : f = g :=
   FunLike.ext f g h
 #align mul_equiv.ext MulEquiv.ext
 #align add_equiv.ext AddEquiv.ext
+-/
 
+#print MulEquiv.ext_iff /-
 @[to_additive]
 theorem ext_iff {f g : MulEquiv M N} : f = g ↔ ∀ x, f x = g x :=
   FunLike.ext_iff
 #align mul_equiv.ext_iff MulEquiv.ext_iff
 #align add_equiv.ext_iff AddEquiv.ext_iff
+-/
 
+#print MulEquiv.mk_coe /-
 @[simp, to_additive]
 theorem mk_coe (e : M ≃* N) (e' h₁ h₂ h₃) : (⟨e, e', h₁, h₂, h₃⟩ : M ≃* N) = e :=
   ext fun _ => rfl
 #align mul_equiv.mk_coe MulEquiv.mk_coe
 #align add_equiv.mk_coe AddEquiv.mk_coe
+-/
 
+#print MulEquiv.mk_coe' /-
 @[simp, to_additive]
 theorem mk_coe' (e : M ≃* N) (f h₁ h₂ h₃) : (MulEquiv.mk f (⇑e) h₁ h₂ h₃ : N ≃* M) = e.symm :=
   symm_bijective.Injective <| ext fun x => rfl
 #align mul_equiv.mk_coe' MulEquiv.mk_coe'
 #align add_equiv.mk_coe' AddEquiv.mk_coe'
+-/
 
+#print MulEquiv.congr_arg /-
 @[to_additive]
 protected theorem congr_arg {f : MulEquiv M N} {x x' : M} : x = x' → f x = f x' :=
   FunLike.congr_arg f
 #align mul_equiv.congr_arg MulEquiv.congr_arg
 #align add_equiv.congr_arg AddEquiv.congr_arg
+-/
 
+#print MulEquiv.congr_fun /-
 @[to_additive]
 protected theorem congr_fun {f g : MulEquiv M N} (h : f = g) (x : M) : f x = g x :=
   FunLike.congr_fun h x
 #align mul_equiv.congr_fun MulEquiv.congr_fun
 #align add_equiv.congr_fun AddEquiv.congr_fun
+-/
 
 #print MulEquiv.mulEquivOfUnique /-
 /-- The `mul_equiv` between two monoids with a unique element. -/
@@ -556,6 +638,7 @@ instance {M N} [Unique M] [Unique N] [Mul M] [Mul N] : Unique (M ≃* N)
 -/
 
 
+#print MulEquiv.map_one /-
 /-- A multiplicative isomorphism of monoids sends `1` to `1` (and is hence a monoid isomorphism). -/
 @[to_additive
       "An additive isomorphism of additive monoids sends `0` to `0`\n(and is hence an additive monoid isomorphism)."]
@@ -563,20 +646,25 @@ protected theorem map_one {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) :
   map_one h
 #align mul_equiv.map_one MulEquiv.map_one
 #align add_equiv.map_zero AddEquiv.map_zero
+-/
 
+#print MulEquiv.map_eq_one_iff /-
 @[to_additive]
 protected theorem map_eq_one_iff {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) {x : M} :
     h x = 1 ↔ x = 1 :=
   MulEquivClass.map_eq_one_iff h
 #align mul_equiv.map_eq_one_iff MulEquiv.map_eq_one_iff
 #align add_equiv.map_eq_zero_iff AddEquiv.map_eq_zero_iff
+-/
 
+#print MulEquiv.map_ne_one_iff /-
 @[to_additive]
 theorem map_ne_one_iff {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) {x : M} :
     h x ≠ 1 ↔ x ≠ 1 :=
   MulEquivClass.map_ne_one_iff h
 #align mul_equiv.map_ne_one_iff MulEquiv.map_ne_one_iff
 #align add_equiv.map_ne_zero_iff AddEquiv.map_ne_zero_iff
+-/
 
 #print MulEquiv.ofBijective /-
 /-- A bijective `semigroup` homomorphism is an isomorphism -/
@@ -588,12 +676,15 @@ noncomputable def ofBijective {M N F} [Mul M] [Mul N] [MulHomClass F M N] (f : F
 #align add_equiv.of_bijective AddEquiv.ofBijective
 -/
 
+#print MulEquiv.ofBijective_apply_symm_apply /-
 @[simp]
 theorem ofBijective_apply_symm_apply {M N} [MulOneClass M] [MulOneClass N] {n : N} (f : M →* N)
     (hf : Function.Bijective f) : f ((Equiv.ofBijective f hf).symm n) = n :=
   (MulEquiv.ofBijective f hf).apply_symm_apply n
 #align mul_equiv.of_bijective_apply_symm_apply MulEquiv.ofBijective_apply_symm_apply
+-/
 
+#print MulEquiv.toMonoidHom /-
 /-- Extract the forward direction of a multiplicative equivalence
 as a multiplication-preserving function.
 -/
@@ -603,19 +694,24 @@ def toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) : M →* N
   { h with map_one' := h.map_one }
 #align mul_equiv.to_monoid_hom MulEquiv.toMonoidHom
 #align add_equiv.to_add_monoid_hom AddEquiv.toAddMonoidHom
+-/
 
+#print MulEquiv.coe_toMonoidHom /-
 @[simp, to_additive]
 theorem coe_toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (e : M ≃* N) : ⇑e.toMonoidHom = e :=
   rfl
 #align mul_equiv.coe_to_monoid_hom MulEquiv.coe_toMonoidHom
 #align add_equiv.coe_to_add_monoid_hom AddEquiv.coe_toAddMonoidHom
+-/
 
+#print MulEquiv.toMonoidHom_injective /-
 @[to_additive]
 theorem toMonoidHom_injective {M N} [MulOneClass M] [MulOneClass N] :
     Function.Injective (toMonoidHom : M ≃* N → M →* N) := fun f g h =>
   MulEquiv.ext (MonoidHom.ext_iff.1 h)
 #align mul_equiv.to_monoid_hom_injective MulEquiv.toMonoidHom_injective
 #align add_equiv.to_add_monoid_hom_injective AddEquiv.toAddMonoidHom_injective
+-/
 
 #print MulEquiv.arrowCongr /-
 /-- A multiplicative analogue of `equiv.arrow_congr`,
@@ -635,6 +731,7 @@ def arrowCongr {M N P Q : Type _} [Mul P] [Mul Q] (f : M ≃ N) (g : P ≃* Q) :
 #align add_equiv.arrow_congr AddEquiv.arrowCongr
 -/
 
+#print MulEquiv.monoidHomCongr /-
 /-- A multiplicative analogue of `equiv.arrow_congr`,
 for multiplicative maps from a monoid to a commutative monoid.
 -/
@@ -651,6 +748,7 @@ def monoidHomCongr {M N P Q} [MulOneClass M] [MulOneClass N] [CommMonoid P] [Com
   map_mul' h k := by ext; simp
 #align mul_equiv.monoid_hom_congr MulEquiv.monoidHomCongr
 #align add_equiv.add_monoid_hom_congr AddEquiv.addMonoidHomCongr
+-/
 
 #print MulEquiv.piCongrRight /-
 /-- A family of multiplicative equivalences `Π j, (Ms j ≃* Ns j)` generates a
@@ -674,20 +772,25 @@ def piCongrRight {η : Type _} {Ms Ns : η → Type _} [∀ j, Mul (Ms j)] [∀
 #align add_equiv.Pi_congr_right AddEquiv.piCongrRight
 -/
 
+#print MulEquiv.piCongrRight_refl /-
 @[simp, to_additive]
 theorem piCongrRight_refl {η : Type _} {Ms : η → Type _} [∀ j, Mul (Ms j)] :
     (piCongrRight fun j => MulEquiv.refl (Ms j)) = MulEquiv.refl _ :=
   rfl
 #align mul_equiv.Pi_congr_right_refl MulEquiv.piCongrRight_refl
 #align add_equiv.Pi_congr_right_refl AddEquiv.piCongrRight_refl
+-/
 
+#print MulEquiv.piCongrRight_symm /-
 @[simp, to_additive]
 theorem piCongrRight_symm {η : Type _} {Ms Ns : η → Type _} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
     (es : ∀ j, Ms j ≃* Ns j) : (piCongrRight es).symm = piCongrRight fun i => (es i).symm :=
   rfl
 #align mul_equiv.Pi_congr_right_symm MulEquiv.piCongrRight_symm
 #align add_equiv.Pi_congr_right_symm AddEquiv.piCongrRight_symm
+-/
 
+#print MulEquiv.piCongrRight_trans /-
 @[simp, to_additive]
 theorem piCongrRight_trans {η : Type _} {Ms Ns Ps : η → Type _} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
     [∀ j, Mul (Ps j)] (es : ∀ j, Ms j ≃* Ns j) (fs : ∀ j, Ns j ≃* Ps j) :
@@ -695,6 +798,7 @@ theorem piCongrRight_trans {η : Type _} {Ms Ns Ps : η → Type _} [∀ j, Mul
   rfl
 #align mul_equiv.Pi_congr_right_trans MulEquiv.piCongrRight_trans
 #align add_equiv.Pi_congr_right_trans AddEquiv.piCongrRight_trans
+-/
 
 #print MulEquiv.piSubsingleton /-
 /-- A family indexed by a nonempty subsingleton type is equivalent to the element at the single
@@ -714,13 +818,16 @@ def piSubsingleton {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)] [Subsing
 -/
 
 
+#print MulEquiv.map_inv /-
 /-- A multiplicative equivalence of groups preserves inversion. -/
 @[to_additive "An additive equivalence of additive groups preserves negation."]
 protected theorem map_inv [Group G] [DivisionMonoid H] (h : G ≃* H) (x : G) : h x⁻¹ = (h x)⁻¹ :=
   map_inv h x
 #align mul_equiv.map_inv MulEquiv.map_inv
 #align add_equiv.map_neg AddEquiv.map_neg
+-/
 
+#print MulEquiv.map_div /-
 /-- A multiplicative equivalence of groups preserves division. -/
 @[to_additive "An additive equivalence of additive groups preserves subtractions."]
 protected theorem map_div [Group G] [DivisionMonoid H] (h : G ≃* H) (x y : G) :
@@ -728,6 +835,7 @@ protected theorem map_div [Group G] [DivisionMonoid H] (h : G ≃* H) (x y : G)
   map_div h x y
 #align mul_equiv.map_div MulEquiv.map_div
 #align add_equiv.map_sub AddEquiv.map_sub
+-/
 
 end MulEquiv
 
@@ -751,6 +859,7 @@ def MulHom.toMulEquiv [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M) (h₁
 #align add_hom.to_add_equiv AddHom.toAddEquiv
 -/
 
+#print MonoidHom.toMulEquiv /-
 /-- Given a pair of monoid homomorphisms `f`, `g` such that `g.comp f = id` and `f.comp g = id`,
 returns an multiplicative equivalence with `to_fun = f` and `inv_fun = g`.  This constructor is
 useful if the underlying type(s) have specialized `ext` lemmas for monoid homomorphisms. -/
@@ -767,6 +876,7 @@ def MonoidHom.toMulEquiv [MulOneClass M] [MulOneClass N] (f : M →* N) (g : N 
   map_mul' := f.map_mul
 #align monoid_hom.to_mul_equiv MonoidHom.toMulEquiv
 #align add_monoid_hom.to_add_equiv AddMonoidHom.toAddEquiv
+-/
 
 namespace Equiv

bump to nightly-2023-06-09-07

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

16afdc39

Diff

@@ -55,7 +55,6 @@ def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M) (h₁ : Funct
       g (x * y) = g (f (g x) * f (g y)) := by rw [h₂ x, h₂ y]
       _ = g (f (g x * g y)) := by rw [f.map_mul]
       _ = g x * g y := h₁ _
-      
 #align mul_hom.inverse MulHom.inverse
 #align add_hom.inverse AddHom.inverse
 -/
@@ -142,8 +141,7 @@ instance (priority := 100) [MulOneClass M] [MulOneClass N] [MulEquivClass F M N]
         e 1 = e 1 * 1 := (mul_one _).symm
         _ = e 1 * e (inv e (1 : N) : M) := (congr_arg _ (right_inv e 1).symm)
         _ = e (inv e (1 : N)) := by rw [← map_mul, one_mul]
-        _ = 1 := right_inv e 1
-         }
+        _ = 1 := right_inv e 1 }
 
 -- See note [lower instance priority]
 instance (priority := 100) toMonoidWithZeroHomClass {α β : Type _} [MulZeroOneClass α]
@@ -152,8 +150,7 @@ instance (priority := 100) toMonoidWithZeroHomClass {α β : Type _} [MulZeroOne
     map_zero := fun e =>
       calc
         e 0 = e 0 * e (EquivLike.inv e 0) := by rw [← map_mul, MulZeroClass.zero_mul]
-        _ = 0 := by convert MulZeroClass.mul_zero _; exact EquivLike.right_inv e _
-         }
+        _ = 0 := by convert MulZeroClass.mul_zero _; exact EquivLike.right_inv e _ }
 #align mul_equiv_class.to_monoid_with_zero_hom_class MulEquivClass.toMonoidWithZeroHomClass
 
 variable {F}

bump to nightly-2023-06-01-04

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

4d9eaa85

Diff

@@ -207,12 +207,11 @@ theorem toEquiv_eq_coe (f : M ≃* N) : f.toEquiv = f :=
 #align mul_equiv.to_equiv_eq_coe MulEquiv.toEquiv_eq_coe
 #align add_equiv.to_equiv_eq_coe AddEquiv.toEquiv_eq_coe
 
-/- warning: mul_equiv.to_fun_eq_coe clashes with [anonymous] -> [anonymous]
-Case conversion may be inaccurate. Consider using '#align mul_equiv.to_fun_eq_coe [anonymous]ₓ'. -/
 @[simp, to_additive]
-theorem [anonymous] {f : M ≃* N} : f.toFun = f :=
+theorem toFun_eq_coe {f : M ≃* N} : f.toFun = f :=
   rfl
-#align mul_equiv.to_fun_eq_coe [anonymous]
+#align mul_equiv.to_fun_eq_coe MulEquiv.toFun_eq_coe
+#align add_equiv.to_fun_eq_coe AddEquiv.toFun_eq_coe
 
 @[simp, to_additive]
 theorem coe_toEquiv {f : M ≃* N} : ⇑(f : M ≃ N) = f :=
@@ -316,13 +315,12 @@ theorem coe_mk (f : M → N) (g h₁ h₂ h₃) : ⇑(MulEquiv.mk f g h₁ h₂
 #align mul_equiv.coe_mk MulEquiv.coe_mkₓ
 #align add_equiv.coe_mk AddEquiv.coe_mkₓ
 
-/- warning: mul_equiv.to_equiv_mk clashes with [anonymous] -> [anonymous]
-Case conversion may be inaccurate. Consider using '#align mul_equiv.to_equiv_mk [anonymous]ₓ'. -/
 @[simp, to_additive]
-theorem [anonymous] (f : M → N) (g : N → M) (h₁ h₂ h₃) :
+theorem toEquiv_mk (f : M → N) (g : N → M) (h₁ h₂ h₃) :
     (mk f g h₁ h₂ h₃).toEquiv = ⟨f, g, h₁, h₂⟩ :=
   rfl
-#align mul_equiv.to_equiv_mk [anonymous]
+#align mul_equiv.to_equiv_mk MulEquiv.toEquiv_mk
+#align add_equiv.to_equiv_mk AddEquiv.to_equiv_mk
 
 @[simp, to_additive]
 theorem symm_symm : ∀ f : M ≃* N, f.symm.symm = f

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -60,12 +60,6 @@ def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M) (h₁ : Funct
 #align add_hom.inverse AddHom.inverse
 -/
 
-/- warning: monoid_hom.inverse -> MonoidHom.inverse is a dubious translation:
-lean 3 declaration is
-  forall {A : Type.{u1}} {B : Type.{u2}} [_inst_1 : Monoid.{u1} A] [_inst_2 : Monoid.{u2} B] (f : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (g : B -> A), (Function.LeftInverse.{succ u1, succ u2} A B g (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (fun (_x : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) => A -> B) (MonoidHom.hasCoeToFun.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) f)) -> (Function.RightInverse.{succ u1, succ u2} A B g (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (fun (_x : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) => A -> B) (MonoidHom.hasCoeToFun.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) f)) -> (MonoidHom.{u2, u1} B A (Monoid.toMulOneClass.{u2} B _inst_2) (Monoid.toMulOneClass.{u1} A _inst_1))
-but is expected to have type
-  forall {A : Type.{u1}} {B : Type.{u2}} [_inst_1 : Monoid.{u1} A] [_inst_2 : Monoid.{u2} B] (f : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (g : B -> A), (Function.LeftInverse.{succ u1, succ u2} A B g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : A) => B) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (MulOneClass.toMul.{u1} A (Monoid.toMulOneClass.{u1} A _inst_1)) (MulOneClass.toMul.{u2} B (Monoid.toMulOneClass.{u2} B _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2) (MonoidHom.monoidHomClass.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)))) f)) -> (Function.RightInverse.{succ u1, succ u2} A B g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : A) => B) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (MulOneClass.toMul.{u1} A (Monoid.toMulOneClass.{u1} A _inst_1)) (MulOneClass.toMul.{u2} B (Monoid.toMulOneClass.{u2} B _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2) (MonoidHom.monoidHomClass.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)))) f)) -> (MonoidHom.{u2, u1} B A (Monoid.toMulOneClass.{u2} B _inst_2) (Monoid.toMulOneClass.{u1} A _inst_1))
-Case conversion may be inaccurate. Consider using '#align monoid_hom.inverse MonoidHom.inverseₓ'. -/
 /-- The inverse of a bijective `monoid_hom` is a `monoid_hom`. -/
 @[to_additive "The inverse of a bijective `add_monoid_hom` is an `add_monoid_hom`.", simps]
 def MonoidHom.inverse {A B : Type _} [Monoid A] [Monoid B] (f : A →* B) (g : B → A)
@@ -151,12 +145,6 @@ instance (priority := 100) [MulOneClass M] [MulOneClass N] [MulEquivClass F M N]
         _ = 1 := right_inv e 1
          }
 
-/- warning: mul_equiv_class.to_monoid_with_zero_hom_class -> MulEquivClass.toMonoidWithZeroHomClass is a dubious translation:
-lean 3 declaration is
-  forall (F : Type.{u1}) {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : MulZeroOneClass.{u2} α] [_inst_2 : MulZeroOneClass.{u3} β] [_inst_3 : MulEquivClass.{u1, u2, u3} F α β (MulZeroClass.toHasMul.{u2} α (MulZeroOneClass.toMulZeroClass.{u2} α _inst_1)) (MulZeroClass.toHasMul.{u3} β (MulZeroOneClass.toMulZeroClass.{u3} β _inst_2))], MonoidWithZeroHomClass.{u1, u2, u3} F α β _inst_1 _inst_2
-but is expected to have type
-  forall (F : Type.{u1}) {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : MulZeroOneClass.{u2} α] [_inst_2 : MulZeroOneClass.{u3} β] [_inst_3 : MulEquivClass.{u1, u2, u3} F α β (MulZeroClass.toMul.{u2} α (MulZeroOneClass.toMulZeroClass.{u2} α _inst_1)) (MulZeroClass.toMul.{u3} β (MulZeroOneClass.toMulZeroClass.{u3} β _inst_2))], MonoidWithZeroHomClass.{u1, u2, u3} F α β _inst_1 _inst_2
-Case conversion may be inaccurate. Consider using '#align mul_equiv_class.to_monoid_with_zero_hom_class MulEquivClass.toMonoidWithZeroHomClassₓ'. -/
 -- See note [lower instance priority]
 instance (priority := 100) toMonoidWithZeroHomClass {α β : Type _} [MulZeroOneClass α]
     [MulZeroOneClass β] [MulEquivClass F α β] : MonoidWithZeroHomClass F α β :=
@@ -170,12 +158,6 @@ instance (priority := 100) toMonoidWithZeroHomClass {α β : Type _} [MulZeroOne
 
 variable {F}
 
-/- warning: mul_equiv_class.map_eq_one_iff -> MulEquivClass.map_eq_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} {M : Type.{u2}} {N : Type.{u3}} [_inst_1 : MulOneClass.{u2} M] [_inst_2 : MulOneClass.{u3} N] [_inst_3 : MulEquivClass.{u1, u2, u3} F M N (MulOneClass.toHasMul.{u2} M _inst_1) (MulOneClass.toHasMul.{u3} N _inst_2)] (h : F) {x : M}, Iff (Eq.{succ u3} N (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F M (fun (_x : M) => N) (EmbeddingLike.toFunLike.{succ u1, succ u2, succ u3} F M N (EquivLike.toEmbeddingLike.{succ u1, succ u2, succ u3} F M N (MulEquivClass.toEquivLike.{u1, u2, u3} F M N (MulOneClass.toHasMul.{u2} M _inst_1) (MulOneClass.toHasMul.{u3} N _inst_2) _inst_3)))) h x) (OfNat.ofNat.{u3} N 1 (OfNat.mk.{u3} N 1 (One.one.{u3} N (MulOneClass.toHasOne.{u3} N _inst_2))))) (Eq.{succ u2} M x (OfNat.ofNat.{u2} M 1 (OfNat.mk.{u2} M 1 (One.one.{u2} M (MulOneClass.toHasOne.{u2} M _inst_1)))))
-but is expected to have type
-  forall {F : Type.{u1}} {M : Type.{u3}} {N : Type.{u2}} [_inst_1 : MulOneClass.{u3} M] [_inst_2 : MulOneClass.{u2} N] [_inst_3 : MulEquivClass.{u1, u3, u2} F M N (MulOneClass.toMul.{u3} M _inst_1) (MulOneClass.toMul.{u2} N _inst_2)] (h : F) {x : M}, Iff (Eq.{succ u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (FunLike.coe.{succ u1, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{succ u1, succ u3, succ u2} F M N (EquivLike.toEmbeddingLike.{succ u1, succ u3, succ u2} F M N (MulEquivClass.toEquivLike.{u1, u3, u2} F M N (MulOneClass.toMul.{u3} M _inst_1) (MulOneClass.toMul.{u2} N _inst_2) _inst_3))) h x) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (MulOneClass.toOne.{u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) _inst_2)))) (Eq.{succ u3} M x (OfNat.ofNat.{u3} M 1 (One.toOfNat1.{u3} M (MulOneClass.toOne.{u3} M _inst_1))))
-Case conversion may be inaccurate. Consider using '#align mul_equiv_class.map_eq_one_iff MulEquivClass.map_eq_one_iffₓ'. -/
 @[simp, to_additive]
 theorem map_eq_one_iff {M N} [MulOneClass M] [MulOneClass N] [MulEquivClass F M N] (h : F) {x : M} :
     h x = 1 ↔ x = 1 :=
@@ -183,12 +165,6 @@ theorem map_eq_one_iff {M N} [MulOneClass M] [MulOneClass N] [MulEquivClass F M
 #align mul_equiv_class.map_eq_one_iff MulEquivClass.map_eq_one_iff
 #align add_equiv_class.map_eq_zero_iff AddEquivClass.map_eq_zero_iff
 
-/- warning: mul_equiv_class.map_ne_one_iff -> MulEquivClass.map_ne_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} {M : Type.{u2}} {N : Type.{u3}} [_inst_1 : MulOneClass.{u2} M] [_inst_2 : MulOneClass.{u3} N] [_inst_3 : MulEquivClass.{u1, u2, u3} F M N (MulOneClass.toHasMul.{u2} M _inst_1) (MulOneClass.toHasMul.{u3} N _inst_2)] (h : F) {x : M}, Iff (Ne.{succ u3} N (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F M (fun (_x : M) => N) (EmbeddingLike.toFunLike.{succ u1, succ u2, succ u3} F M N (EquivLike.toEmbeddingLike.{succ u1, succ u2, succ u3} F M N (MulEquivClass.toEquivLike.{u1, u2, u3} F M N (MulOneClass.toHasMul.{u2} M _inst_1) (MulOneClass.toHasMul.{u3} N _inst_2) _inst_3)))) h x) (OfNat.ofNat.{u3} N 1 (OfNat.mk.{u3} N 1 (One.one.{u3} N (MulOneClass.toHasOne.{u3} N _inst_2))))) (Ne.{succ u2} M x (OfNat.ofNat.{u2} M 1 (OfNat.mk.{u2} M 1 (One.one.{u2} M (MulOneClass.toHasOne.{u2} M _inst_1)))))
-but is expected to have type
-  forall {F : Type.{u1}} {M : Type.{u3}} {N : Type.{u2}} [_inst_1 : MulOneClass.{u3} M] [_inst_2 : MulOneClass.{u2} N] [_inst_3 : MulEquivClass.{u1, u3, u2} F M N (MulOneClass.toMul.{u3} M _inst_1) (MulOneClass.toMul.{u2} N _inst_2)] (h : F) {x : M}, Iff (Ne.{succ u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (FunLike.coe.{succ u1, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{succ u1, succ u3, succ u2} F M N (EquivLike.toEmbeddingLike.{succ u1, succ u3, succ u2} F M N (MulEquivClass.toEquivLike.{u1, u3, u2} F M N (MulOneClass.toMul.{u3} M _inst_1) (MulOneClass.toMul.{u2} N _inst_2) _inst_3))) h x) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (MulOneClass.toOne.{u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) _inst_2)))) (Ne.{succ u3} M x (OfNat.ofNat.{u3} M 1 (One.toOfNat1.{u3} M (MulOneClass.toOne.{u3} M _inst_1))))
-Case conversion may be inaccurate. Consider using '#align mul_equiv_class.map_ne_one_iff MulEquivClass.map_ne_one_iffₓ'. -/
 @[to_additive]
 theorem map_ne_one_iff {M N} [MulOneClass M] [MulOneClass N] [MulEquivClass F M N] (h : F) {x : M} :
     h x ≠ 1 ↔ x ≠ 1 :=
@@ -225,12 +201,6 @@ instance [Mul M] [Mul N] : MulEquivClass (M ≃* N) M N
 
 variable [Mul M] [Mul N] [Mul P] [Mul Q]
 
-/- warning: mul_equiv.to_equiv_eq_coe -> MulEquiv.toEquiv_eq_coe is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (f : MulEquiv.{u1, u2} M N _inst_1 _inst_2), Eq.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{succ u1, succ u2} M N) (MulEquiv.toEquiv.{u1, u2} M N _inst_1 _inst_2 f) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)}) [self : HasLiftT.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} a b] => self.0) (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (HasLiftT.mk.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (CoeTCₓ.coe.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (Equiv.hasCoeT.{succ u1, succ u2, max (succ u1) (succ u2)} M N (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.mulEquivClass.{u1, u2} M N _inst_1 _inst_2))))) f)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (f : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{max (succ u2) (succ u1)} (Equiv.{succ u2, succ u1} M N) (MulEquiv.toEquiv.{u2, u1} M N _inst_1 _inst_2 f) (EquivLike.toEquiv.{succ u2, succ u1, max (succ u2) (succ u1)} M N (MulEquiv.{u2, u1} M N _inst_1 _inst_2) (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)) f)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.to_equiv_eq_coe MulEquiv.toEquiv_eq_coeₓ'. -/
 @[simp, to_additive]
 theorem toEquiv_eq_coe (f : M ≃* N) : f.toEquiv = f :=
   rfl
@@ -238,47 +208,24 @@ theorem toEquiv_eq_coe (f : M ≃* N) : f.toEquiv = f :=
 #align add_equiv.to_equiv_eq_coe AddEquiv.toEquiv_eq_coe
 
 /- warning: mul_equiv.to_fun_eq_coe clashes with [anonymous] -> [anonymous]
-warning: mul_equiv.to_fun_eq_coe -> [anonymous] is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {f : MulEquiv.{u1, u2} M N _inst_1 _inst_2}, Eq.{max (succ u1) (succ u2)} (M -> N) (MulEquiv.toFun.{u1, u2} M N _inst_1 _inst_2 f) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f)
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}}, (Nat -> M -> N) -> Nat -> (List.{u1} M) -> (List.{u2} N)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.to_fun_eq_coe [anonymous]ₓ'. -/
 @[simp, to_additive]
 theorem [anonymous] {f : M ≃* N} : f.toFun = f :=
   rfl
 #align mul_equiv.to_fun_eq_coe [anonymous]
 
-/- warning: mul_equiv.coe_to_equiv -> MulEquiv.coe_toEquiv is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {f : MulEquiv.{u1, u2} M N _inst_1 _inst_2}, Eq.{max (succ u1) (succ u2)} (M -> N) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} M N) (fun (_x : Equiv.{succ u1, succ u2} M N) => M -> N) (Equiv.hasCoeToFun.{succ u1, succ u2} M N) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)}) [self : HasLiftT.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} a b] => self.0) (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (HasLiftT.mk.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (CoeTCₓ.coe.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (Equiv.hasCoeT.{succ u1, succ u2, max (succ u1) (succ u2)} M N (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.mulEquivClass.{u1, u2} M N _inst_1 _inst_2))))) f)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (f : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} M N) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => N) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} M N) (EquivLike.toEquiv.{succ u2, succ u1, max (succ u2) (succ u1)} M N (MulEquiv.{u2, u1} M N _inst_1 _inst_2) (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)) f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.coe_to_equiv MulEquiv.coe_toEquivₓ'. -/
 @[simp, to_additive]
 theorem coe_toEquiv {f : M ≃* N} : ⇑(f : M ≃ N) = f :=
   rfl
 #align mul_equiv.coe_to_equiv MulEquiv.coe_toEquiv
 #align add_equiv.coe_to_equiv AddEquiv.coe_toEquiv
 
-/- warning: mul_equiv.coe_to_mul_hom -> MulEquiv.coe_toMulHom is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {f : MulEquiv.{u1, u2} M N _inst_1 _inst_2}, Eq.{max (succ u1) (succ u2)} (M -> N) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulHom.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) (MulEquiv.toMulHom.{u1, u2} M N _inst_1 _inst_2 f)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {f : MulEquiv.{u2, u1} M N _inst_1 _inst_2}, Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulHom.mulHomClass.{u2, u1} M N _inst_1 _inst_2)) (MulEquiv.toMulHom.{u2, u1} M N _inst_1 _inst_2 f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.coe_to_mul_hom MulEquiv.coe_toMulHomₓ'. -/
 @[simp, to_additive]
 theorem coe_toMulHom {f : M ≃* N} : ⇑f.toMulHom = f :=
   rfl
 #align mul_equiv.coe_to_mul_hom MulEquiv.coe_toMulHom
 #align add_equiv.coe_to_add_hom AddEquiv.coe_toAddHom
 
-/- warning: mul_equiv.map_mul -> MulEquiv.map_mul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (f : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (x : M) (y : M), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x y)) (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N _inst_2) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f y))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (f : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (x : M) (y : M), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M _inst_1) x y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M _inst_1) x y)) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) y) ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f y))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.map_mul MulEquiv.map_mulₓ'. -/
 /-- A multiplicative isomorphism preserves multiplication. -/
 @[to_additive "An additive isomorphism preserves addition."]
 protected theorem map_mul (f : M ≃* N) : ∀ x y, f (x * y) = f x * f y :=
@@ -295,36 +242,18 @@ def mk' (f : M ≃ N) (h : ∀ x y, f (x * y) = f x * f y) : M ≃* N :=
 #align add_equiv.mk' AddEquiv.mk'
 -/
 
-/- warning: mul_equiv.bijective -> MulEquiv.bijective is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2), Function.Bijective.{succ u1, succ u2} M N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Function.Bijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.bijective MulEquiv.bijectiveₓ'. -/
 @[to_additive]
 protected theorem bijective (e : M ≃* N) : Function.Bijective e :=
   EquivLike.bijective e
 #align mul_equiv.bijective MulEquiv.bijective
 #align add_equiv.bijective AddEquiv.bijective
 
-/- warning: mul_equiv.injective -> MulEquiv.injective is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2), Function.Injective.{succ u1, succ u2} M N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Function.Injective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.injective MulEquiv.injectiveₓ'. -/
 @[to_additive]
 protected theorem injective (e : M ≃* N) : Function.Injective e :=
   EquivLike.injective e
 #align mul_equiv.injective MulEquiv.injective
 #align add_equiv.injective AddEquiv.injective
 
-/- warning: mul_equiv.surjective -> MulEquiv.surjective is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2), Function.Surjective.{succ u1, succ u2} M N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Function.Surjective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.surjective MulEquiv.surjectiveₓ'. -/
 @[to_additive]
 protected theorem surjective (e : M ≃* N) : Function.Surjective e :=
   EquivLike.surjective e
@@ -354,12 +283,6 @@ def symm (h : M ≃* N) : N ≃* M :=
 #align add_equiv.symm AddEquiv.symm
 -/
 
-/- warning: mul_equiv.inv_fun_eq_symm -> MulEquiv.invFun_eq_symm is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {f : MulEquiv.{u1, u2} M N _inst_1 _inst_2}, Eq.{max (succ u2) (succ u1)} (N -> M) (MulEquiv.invFun.{u1, u2} M N _inst_1 _inst_2 f) (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 f))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {f : MulEquiv.{u2, u1} M N _inst_1 _inst_2}, Eq.{max (succ u2) (succ u1)} (N -> M) (Equiv.invFun.{succ u2, succ u1} M N (MulEquiv.toEquiv.{u2, u1} M N _inst_1 _inst_2 f)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 f))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.inv_fun_eq_symm MulEquiv.invFun_eq_symmₓ'. -/
 @[simp, to_additive]
 theorem invFun_eq_symm {f : M ≃* N} : f.invFun = f.symm :=
   rfl
@@ -381,12 +304,6 @@ initialize_simps_projections AddEquiv (toFun → apply, invFun → symm_apply)
 
 initialize_simps_projections MulEquiv (toFun → apply, invFun → symm_apply)
 
-/- warning: mul_equiv.to_equiv_symm -> MulEquiv.toEquiv_symm is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (f : MulEquiv.{u1, u2} M N _inst_1 _inst_2), Eq.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2)} (Equiv.{succ u2, succ u1} N M) (MulEquiv.toEquiv.{u2, u1} N M _inst_2 _inst_1 (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 f)) (Equiv.symm.{succ u1, succ u2} M N (MulEquiv.toEquiv.{u1, u2} M N _inst_1 _inst_2 f))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (f : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{max (succ u2) (succ u1)} (Equiv.{succ u1, succ u2} N M) (EquivLike.toEquiv.{succ u1, succ u2, max (succ u2) (succ u1)} N M (MulEquiv.{u1, u2} N M _inst_2 _inst_1) (MulEquivClass.toEquivLike.{max u2 u1, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 f)) (Equiv.symm.{succ u2, succ u1} M N (EquivLike.toEquiv.{succ u2, succ u1, max (succ u2) (succ u1)} M N (MulEquiv.{u2, u1} M N _inst_1 _inst_2) (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)) f))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.to_equiv_symm MulEquiv.toEquiv_symmₓ'. -/
 @[simp, to_additive]
 theorem toEquiv_symm (f : M ≃* N) : f.symm.toEquiv = f.toEquiv.symm :=
   rfl
@@ -400,11 +317,6 @@ theorem coe_mk (f : M → N) (g h₁ h₂ h₃) : ⇑(MulEquiv.mk f g h₁ h₂
 #align add_equiv.coe_mk AddEquiv.coe_mkₓ
 
 /- warning: mul_equiv.to_equiv_mk clashes with [anonymous] -> [anonymous]
-warning: mul_equiv.to_equiv_mk -> [anonymous] is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (f : M -> N) (g : N -> M) (h₁ : Function.LeftInverse.{succ u1, succ u2} M N g f) (h₂ : Function.RightInverse.{succ u1, succ u2} M N g f) (h₃ : forall (x : M) (y : M), Eq.{succ u2} N (f (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x y)) (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N _inst_2) (f x) (f y))), Eq.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{succ u1, succ u2} M N) (MulEquiv.toEquiv.{u1, u2} M N _inst_1 _inst_2 (MulEquiv.mk.{u1, u2} M N _inst_1 _inst_2 f g h₁ h₂ h₃)) (Equiv.mk.{succ u1, succ u2} M N f g h₁ h₂)
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}}, (Nat -> M -> N) -> Nat -> (List.{u1} M) -> (List.{u2} N)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.to_equiv_mk [anonymous]ₓ'. -/
 @[simp, to_additive]
 theorem [anonymous] (f : M → N) (g : N → M) (h₁ h₂ h₃) :
@@ -412,24 +324,12 @@ theorem [anonymous] (f : M → N) (g : N → M) (h₁ h₂ h₃) :
   rfl
 #align mul_equiv.to_equiv_mk [anonymous]
 
-/- warning: mul_equiv.symm_symm -> MulEquiv.symm_symm is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (f : MulEquiv.{u1, u2} M N _inst_1 _inst_2), Eq.{max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (MulEquiv.symm.{u2, u1} N M _inst_2 _inst_1 (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 f)) f
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (f : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{max (succ u2) (succ u1)} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) (MulEquiv.symm.{u1, u2} N M _inst_2 _inst_1 (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 f)) f
-Case conversion may be inaccurate. Consider using '#align mul_equiv.symm_symm MulEquiv.symm_symmₓ'. -/
 @[simp, to_additive]
 theorem symm_symm : ∀ f : M ≃* N, f.symm.symm = f
   | ⟨f, g, h₁, h₂, h₃⟩ => rfl
 #align mul_equiv.symm_symm MulEquiv.symm_symm
 #align add_equiv.symm_symm AddEquiv.symm_symm
 
-/- warning: mul_equiv.symm_bijective -> MulEquiv.symm_bijective is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N], Function.Bijective.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N], Function.Bijective.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) (MulEquiv.{u1, u2} N M _inst_2 _inst_1) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.symm_bijective MulEquiv.symm_bijectiveₓ'. -/
 @[to_additive]
 theorem symm_bijective : Function.Bijective (symm : M ≃* N → N ≃* M) :=
   Equiv.bijective ⟨symm, symm, symm_symm, symm_symm⟩
@@ -465,12 +365,6 @@ def trans (h1 : M ≃* N) (h2 : N ≃* P) : M ≃* P :=
 #align add_equiv.trans AddEquiv.trans
 -/
 
-/- warning: mul_equiv.apply_symm_apply -> MulEquiv.apply_symm_apply is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (y : N), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e) y)) y
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (y : N), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (a : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) a) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) y)) y
-Case conversion may be inaccurate. Consider using '#align mul_equiv.apply_symm_apply MulEquiv.apply_symm_applyₓ'. -/
 /-- `e.symm` is a right inverse of `e`, written as `e (e.symm y) = y`. -/
 @[simp, to_additive "`e.symm` is a right inverse of `e`, written as `e (e.symm y) = y`."]
 theorem apply_symm_apply (e : M ≃* N) (y : N) : e (e.symm y) = y :=
@@ -478,12 +372,6 @@ theorem apply_symm_apply (e : M ≃* N) (y : N) : e (e.symm y) = y :=
 #align mul_equiv.apply_symm_apply MulEquiv.apply_symm_apply
 #align add_equiv.apply_symm_apply AddEquiv.apply_symm_apply
 
-/- warning: mul_equiv.symm_apply_apply -> MulEquiv.symm_apply_apply is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (x : M), Eq.{succ u1} M (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e x)) x
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (a : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e x)) x
-Case conversion may be inaccurate. Consider using '#align mul_equiv.symm_apply_apply MulEquiv.symm_apply_applyₓ'. -/
 /-- `e.symm` is a left inverse of `e`, written as `e.symm (e y) = y`. -/
 @[simp, to_additive "`e.symm` is a left inverse of `e`, written as `e.symm (e y) = y`."]
 theorem symm_apply_apply (e : M ≃* N) (x : M) : e.symm (e x) = x :=
@@ -491,84 +379,42 @@ theorem symm_apply_apply (e : M ≃* N) (x : M) : e.symm (e x) = x :=
 #align mul_equiv.symm_apply_apply MulEquiv.symm_apply_apply
 #align add_equiv.symm_apply_apply AddEquiv.symm_apply_apply
 
-/- warning: mul_equiv.symm_comp_self -> MulEquiv.symm_comp_self is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2), Eq.{succ u1} (M -> M) (Function.comp.{succ u1, succ u2, succ u1} M N M (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e)) (id.{succ u1} M)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{succ u2} (M -> M) (Function.comp.{succ u2, succ u1, succ u2} M N M (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e)) (id.{succ u2} M)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.symm_comp_self MulEquiv.symm_comp_selfₓ'. -/
 @[simp, to_additive]
 theorem symm_comp_self (e : M ≃* N) : e.symm ∘ e = id :=
   funext e.symm_apply_apply
 #align mul_equiv.symm_comp_self MulEquiv.symm_comp_self
 #align add_equiv.symm_comp_self AddEquiv.symm_comp_self
 
-/- warning: mul_equiv.self_comp_symm -> MulEquiv.self_comp_symm is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2), Eq.{succ u2} (N -> N) (Function.comp.{succ u2, succ u1, succ u2} N M N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e) (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e))) (id.{succ u2} N)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{succ u1} (N -> N) (Function.comp.{succ u1, succ u2, succ u1} N M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e))) (id.{succ u1} N)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.self_comp_symm MulEquiv.self_comp_symmₓ'. -/
 @[simp, to_additive]
 theorem self_comp_symm (e : M ≃* N) : e ∘ e.symm = id :=
   funext e.apply_symm_apply
 #align mul_equiv.self_comp_symm MulEquiv.self_comp_symm
 #align add_equiv.self_comp_symm AddEquiv.self_comp_symm
 
-/- warning: mul_equiv.coe_refl -> MulEquiv.coe_refl is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M], Eq.{succ u1} (M -> M) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} M M _inst_1 _inst_1) (fun (_x : MulEquiv.{u1, u1} M M _inst_1 _inst_1) => M -> M) (MulEquiv.hasCoeToFun.{u1, u1} M M _inst_1 _inst_1) (MulEquiv.refl.{u1} M _inst_1)) (id.{succ u1} M)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M], Eq.{succ u1} (M -> M) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} M M _inst_1 _inst_1) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => M) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} M M _inst_1 _inst_1) M M (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} M M _inst_1 _inst_1) M M (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} M M _inst_1 _inst_1) M M _inst_1 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} M M _inst_1 _inst_1)))) (MulEquiv.refl.{u1} M _inst_1)) (id.{succ u1} M)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.coe_refl MulEquiv.coe_reflₓ'. -/
 @[simp, to_additive]
 theorem coe_refl : ⇑(refl M) = id :=
   rfl
 #align mul_equiv.coe_refl MulEquiv.coe_refl
 #align add_equiv.coe_refl AddEquiv.coe_refl
 
-/- warning: mul_equiv.refl_apply -> MulEquiv.refl_apply is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] (m : M), Eq.{succ u1} M (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} M M _inst_1 _inst_1) (fun (_x : MulEquiv.{u1, u1} M M _inst_1 _inst_1) => M -> M) (MulEquiv.hasCoeToFun.{u1, u1} M M _inst_1 _inst_1) (MulEquiv.refl.{u1} M _inst_1) m) m
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] (m : M), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => M) m) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} M M _inst_1 _inst_1) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => M) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} M M _inst_1 _inst_1) M M (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} M M _inst_1 _inst_1) M M (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} M M _inst_1 _inst_1) M M _inst_1 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} M M _inst_1 _inst_1)))) (MulEquiv.refl.{u1} M _inst_1) m) m
-Case conversion may be inaccurate. Consider using '#align mul_equiv.refl_apply MulEquiv.refl_applyₓ'. -/
 @[simp, to_additive]
 theorem refl_apply (m : M) : refl M m = m :=
   rfl
 #align mul_equiv.refl_apply MulEquiv.refl_apply
 #align add_equiv.refl_apply AddEquiv.refl_apply
 
-/- warning: mul_equiv.coe_trans -> MulEquiv.coe_trans is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} {P : Type.{u3}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] [_inst_3 : Mul.{u3} P] (e₁ : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (e₂ : MulEquiv.{u2, u3} N P _inst_2 _inst_3), Eq.{max (succ u1) (succ u3)} (M -> P) (coeFn.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (MulEquiv.{u1, u3} M P _inst_1 _inst_3) (fun (_x : MulEquiv.{u1, u3} M P _inst_1 _inst_3) => M -> P) (MulEquiv.hasCoeToFun.{u1, u3} M P _inst_1 _inst_3) (MulEquiv.trans.{u1, u2, u3} M N P _inst_1 _inst_2 _inst_3 e₁ e₂)) (Function.comp.{succ u1, succ u2, succ u3} M N P (coeFn.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (MulEquiv.{u2, u3} N P _inst_2 _inst_3) (fun (_x : MulEquiv.{u2, u3} N P _inst_2 _inst_3) => N -> P) (MulEquiv.hasCoeToFun.{u2, u3} N P _inst_2 _inst_3) e₂) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e₁))
-but is expected to have type
-  forall {M : Type.{u3}} {N : Type.{u2}} {P : Type.{u1}} [_inst_1 : Mul.{u3} M] [_inst_2 : Mul.{u2} N] [_inst_3 : Mul.{u1} P] (e₁ : MulEquiv.{u3, u2} M N _inst_1 _inst_2) (e₂ : MulEquiv.{u2, u1} N P _inst_2 _inst_3), Eq.{max (succ u3) (succ u1)} (M -> P) (FunLike.coe.{max (succ u3) (succ u1), succ u3, succ u1} (MulEquiv.{u3, u1} M P _inst_1 _inst_3) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => P) _x) (EmbeddingLike.toFunLike.{max (succ u3) (succ u1), succ u3, succ u1} (MulEquiv.{u3, u1} M P _inst_1 _inst_3) M P (EquivLike.toEmbeddingLike.{max (succ u3) (succ u1), succ u3, succ u1} (MulEquiv.{u3, u1} M P _inst_1 _inst_3) M P (MulEquivClass.toEquivLike.{max u3 u1, u3, u1} (MulEquiv.{u3, u1} M P _inst_1 _inst_3) M P _inst_1 _inst_3 (MulEquiv.instMulEquivClassMulEquiv.{u3, u1} M P _inst_1 _inst_3)))) (MulEquiv.trans.{u3, u2, u1} M N P _inst_1 _inst_2 _inst_3 e₁ e₂)) (Function.comp.{succ u3, succ u2, succ u1} M N P (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} N P _inst_2 _inst_3) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => P) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} N P _inst_2 _inst_3) N P (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} N P _inst_2 _inst_3) N P (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} N P _inst_2 _inst_3) N P _inst_2 _inst_3 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} N P _inst_2 _inst_3)))) e₂) (FunLike.coe.{max (succ u3) (succ u2), succ u3, succ u2} (MulEquiv.{u3, u2} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u3) (succ u2), succ u3, succ u2} (MulEquiv.{u3, u2} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u3) (succ u2), succ u3, succ u2} (MulEquiv.{u3, u2} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u3 u2, u3, u2} (MulEquiv.{u3, u2} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u3, u2} M N _inst_1 _inst_2)))) e₁))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.coe_trans MulEquiv.coe_transₓ'. -/
 @[simp, to_additive]
 theorem coe_trans (e₁ : M ≃* N) (e₂ : N ≃* P) : ⇑(e₁.trans e₂) = e₂ ∘ e₁ :=
   rfl
 #align mul_equiv.coe_trans MulEquiv.coe_trans
 #align add_equiv.coe_trans AddEquiv.coe_trans
 
-/- warning: mul_equiv.trans_apply -> MulEquiv.trans_apply is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} {P : Type.{u3}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] [_inst_3 : Mul.{u3} P] (e₁ : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (e₂ : MulEquiv.{u2, u3} N P _inst_2 _inst_3) (m : M), Eq.{succ u3} P (coeFn.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (MulEquiv.{u1, u3} M P _inst_1 _inst_3) (fun (_x : MulEquiv.{u1, u3} M P _inst_1 _inst_3) => M -> P) (MulEquiv.hasCoeToFun.{u1, u3} M P _inst_1 _inst_3) (MulEquiv.trans.{u1, u2, u3} M N P _inst_1 _inst_2 _inst_3 e₁ e₂) m) (coeFn.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (MulEquiv.{u2, u3} N P _inst_2 _inst_3) (fun (_x : MulEquiv.{u2, u3} N P _inst_2 _inst_3) => N -> P) (MulEquiv.hasCoeToFun.{u2, u3} N P _inst_2 _inst_3) e₂ (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e₁ m))
-but is expected to have type
-  forall {M : Type.{u3}} {N : Type.{u2}} {P : Type.{u1}} [_inst_1 : Mul.{u3} M] [_inst_2 : Mul.{u2} N] [_inst_3 : Mul.{u1} P] (e₁ : MulEquiv.{u3, u2} M N _inst_1 _inst_2) (e₂ : MulEquiv.{u2, u1} N P _inst_2 _inst_3) (m : M), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => P) m) (FunLike.coe.{max (succ u3) (succ u1), succ u3, succ u1} (MulEquiv.{u3, u1} M P _inst_1 _inst_3) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => P) _x) (EmbeddingLike.toFunLike.{max (succ u3) (succ u1), succ u3, succ u1} (MulEquiv.{u3, u1} M P _inst_1 _inst_3) M P (EquivLike.toEmbeddingLike.{max (succ u3) (succ u1), succ u3, succ u1} (MulEquiv.{u3, u1} M P _inst_1 _inst_3) M P (MulEquivClass.toEquivLike.{max u3 u1, u3, u1} (MulEquiv.{u3, u1} M P _inst_1 _inst_3) M P _inst_1 _inst_3 (MulEquiv.instMulEquivClassMulEquiv.{u3, u1} M P _inst_1 _inst_3)))) (MulEquiv.trans.{u3, u2, u1} M N P _inst_1 _inst_2 _inst_3 e₁ e₂) m) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} N P _inst_2 _inst_3) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => P) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} N P _inst_2 _inst_3) N P (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} N P _inst_2 _inst_3) N P (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} N P _inst_2 _inst_3) N P _inst_2 _inst_3 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} N P _inst_2 _inst_3)))) e₂ (FunLike.coe.{max (succ u3) (succ u2), succ u3, succ u2} (MulEquiv.{u3, u2} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u3) (succ u2), succ u3, succ u2} (MulEquiv.{u3, u2} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u3) (succ u2), succ u3, succ u2} (MulEquiv.{u3, u2} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u3 u2, u3, u2} (MulEquiv.{u3, u2} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u3, u2} M N _inst_1 _inst_2)))) e₁ m))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.trans_apply MulEquiv.trans_applyₓ'. -/
 @[simp, to_additive]
 theorem trans_apply (e₁ : M ≃* N) (e₂ : N ≃* P) (m : M) : e₁.trans e₂ m = e₂ (e₁ m) :=
   rfl
 #align mul_equiv.trans_apply MulEquiv.trans_apply
 #align add_equiv.trans_apply AddEquiv.trans_apply
 
-/- warning: mul_equiv.symm_trans_apply -> MulEquiv.symm_trans_apply is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} {P : Type.{u3}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] [_inst_3 : Mul.{u3} P] (e₁ : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (e₂ : MulEquiv.{u2, u3} N P _inst_2 _inst_3) (p : P), Eq.{succ u1} M (coeFn.{max (succ u3) (succ u1), max (succ u3) (succ u1)} (MulEquiv.{u3, u1} P M _inst_3 _inst_1) (fun (_x : MulEquiv.{u3, u1} P M _inst_3 _inst_1) => P -> M) (MulEquiv.hasCoeToFun.{u3, u1} P M _inst_3 _inst_1) (MulEquiv.symm.{u1, u3} M P _inst_1 _inst_3 (MulEquiv.trans.{u1, u2, u3} M N P _inst_1 _inst_2 _inst_3 e₁ e₂)) p) (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e₁) (coeFn.{max (succ u3) (succ u2), max (succ u3) (succ u2)} (MulEquiv.{u3, u2} P N _inst_3 _inst_2) (fun (_x : MulEquiv.{u3, u2} P N _inst_3 _inst_2) => P -> N) (MulEquiv.hasCoeToFun.{u3, u2} P N _inst_3 _inst_2) (MulEquiv.symm.{u2, u3} N P _inst_2 _inst_3 e₂) p))
-but is expected to have type
-  forall {M : Type.{u3}} {N : Type.{u2}} {P : Type.{u1}} [_inst_1 : Mul.{u3} M] [_inst_2 : Mul.{u2} N] [_inst_3 : Mul.{u1} P] (e₁ : MulEquiv.{u3, u2} M N _inst_1 _inst_2) (e₂ : MulEquiv.{u2, u1} N P _inst_2 _inst_3) (p : P), Eq.{succ u3} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : P) => M) p) (FunLike.coe.{max (succ u1) (succ u3), succ u1, succ u3} (MulEquiv.{u1, u3} P M _inst_3 _inst_1) P (fun (_x : P) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : P) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u3), succ u1, succ u3} (MulEquiv.{u1, u3} P M _inst_3 _inst_1) P M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u3), succ u1, succ u3} (MulEquiv.{u1, u3} P M _inst_3 _inst_1) P M (MulEquivClass.toEquivLike.{max u1 u3, u1, u3} (MulEquiv.{u1, u3} P M _inst_3 _inst_1) P M _inst_3 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u3} P M _inst_3 _inst_1)))) (MulEquiv.symm.{u3, u1} M P _inst_1 _inst_3 (MulEquiv.trans.{u3, u2, u1} M N P _inst_1 _inst_2 _inst_3 e₁ e₂)) p) (FunLike.coe.{max (succ u2) (succ u3), succ u2, succ u3} (MulEquiv.{u2, u3} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u3), succ u2, succ u3} (MulEquiv.{u2, u3} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u2) (succ u3), succ u2, succ u3} (MulEquiv.{u2, u3} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u2 u3, u2, u3} (MulEquiv.{u2, u3} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u2, u3} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u3, u2} M N _inst_1 _inst_2 e₁) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} P N _inst_3 _inst_2) P (fun (_x : P) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : P) => N) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} P N _inst_3 _inst_2) P N (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} P N _inst_3 _inst_2) P N (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} P N _inst_3 _inst_2) P N _inst_3 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} P N _inst_3 _inst_2)))) (MulEquiv.symm.{u2, u1} N P _inst_2 _inst_3 e₂) p))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.symm_trans_apply MulEquiv.symm_trans_applyₓ'. -/
 @[simp, to_additive]
 theorem symm_trans_apply (e₁ : M ≃* N) (e₂ : N ≃* P) (p : P) :
     (e₁.trans e₂).symm p = e₁.symm (e₂.symm p) :=
@@ -576,60 +422,30 @@ theorem symm_trans_apply (e₁ : M ≃* N) (e₂ : N ≃* P) (p : P) :
 #align mul_equiv.symm_trans_apply MulEquiv.symm_trans_apply
 #align add_equiv.symm_trans_apply AddEquiv.symm_trans_apply
 
-/- warning: mul_equiv.apply_eq_iff_eq -> MulEquiv.apply_eq_iff_eq is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) {x : M} {y : M}, Iff (Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e y)) (Eq.{succ u1} M x y)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) {x : M} {y : M}, Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e y)) (Eq.{succ u2} M x y)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.apply_eq_iff_eq MulEquiv.apply_eq_iff_eqₓ'. -/
 @[simp, to_additive]
 theorem apply_eq_iff_eq (e : M ≃* N) {x y : M} : e x = e y ↔ x = y :=
   e.Injective.eq_iff
 #align mul_equiv.apply_eq_iff_eq MulEquiv.apply_eq_iff_eq
 #align add_equiv.apply_eq_iff_eq AddEquiv.apply_eq_iff_eq
 
-/- warning: mul_equiv.apply_eq_iff_symm_apply -> MulEquiv.apply_eq_iff_symm_apply is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) {x : M} {y : N}, Iff (Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e x) y) (Eq.{succ u1} M x (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e) y))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) {x : M} {y : N}, Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e x) y) (Eq.{succ u2} M x (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) y))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.apply_eq_iff_symm_apply MulEquiv.apply_eq_iff_symm_applyₓ'. -/
 @[to_additive]
 theorem apply_eq_iff_symm_apply (e : M ≃* N) {x : M} {y : N} : e x = y ↔ x = e.symm y :=
   e.toEquiv.apply_eq_iff_eq_symm_apply
 #align mul_equiv.apply_eq_iff_symm_apply MulEquiv.apply_eq_iff_symm_apply
 #align add_equiv.apply_eq_iff_symm_apply AddEquiv.apply_eq_iff_symm_apply
 
-/- warning: mul_equiv.symm_apply_eq -> MulEquiv.symm_apply_eq is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) {x : N} {y : M}, Iff (Eq.{succ u1} M (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e) x) y) (Eq.{succ u2} N x (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e y))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) {x : N} {y : (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) x}, Iff (Eq.{succ u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) x) y) (Eq.{succ u1} N x (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e y))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.symm_apply_eq MulEquiv.symm_apply_eqₓ'. -/
 @[to_additive]
 theorem symm_apply_eq (e : M ≃* N) {x y} : e.symm x = y ↔ x = e y :=
   e.toEquiv.symm_apply_eq
 #align mul_equiv.symm_apply_eq MulEquiv.symm_apply_eq
 #align add_equiv.symm_apply_eq AddEquiv.symm_apply_eq
 
-/- warning: mul_equiv.eq_symm_apply -> MulEquiv.eq_symm_apply is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) {x : N} {y : M}, Iff (Eq.{succ u1} M y (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e) x)) (Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e y) x)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) {x : N} {y : (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) x}, Iff (Eq.{succ u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) x) y (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) x)) (Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) y) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e y) x)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.eq_symm_apply MulEquiv.eq_symm_applyₓ'. -/
 @[to_additive]
 theorem eq_symm_apply (e : M ≃* N) {x y} : y = e.symm x ↔ e y = x :=
   e.toEquiv.eq_symm_apply
 #align mul_equiv.eq_symm_apply MulEquiv.eq_symm_apply
 #align add_equiv.eq_symm_apply AddEquiv.eq_symm_apply
 
-/- warning: mul_equiv.eq_comp_symm -> MulEquiv.eq_comp_symm is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {α : Type.{u3}} (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (f : N -> α) (g : M -> α), Iff (Eq.{max (succ u2) (succ u3)} (N -> α) f (Function.comp.{succ u2, succ u1, succ u3} N M α g (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e)))) (Eq.{max (succ u1) (succ u3)} (M -> α) (Function.comp.{succ u1, succ u2, succ u3} M N α f (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e)) g)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {α : Type.{u3}} (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (f : N -> α) (g : M -> α), Iff (Eq.{max (succ u1) (succ u3)} (N -> α) f (Function.comp.{succ u1, succ u2, succ u3} N M α g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e)))) (Eq.{max (succ u2) (succ u3)} (M -> α) (Function.comp.{succ u2, succ u1, succ u3} M N α f (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e)) g)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.eq_comp_symm MulEquiv.eq_comp_symmₓ'. -/
 @[to_additive]
 theorem eq_comp_symm {α : Type _} (e : M ≃* N) (f : N → α) (g : M → α) :
     f = g ∘ e.symm ↔ f ∘ e = g :=
@@ -637,12 +453,6 @@ theorem eq_comp_symm {α : Type _} (e : M ≃* N) (f : N → α) (g : M → α)
 #align mul_equiv.eq_comp_symm MulEquiv.eq_comp_symm
 #align add_equiv.eq_comp_symm AddEquiv.eq_comp_symm
 
-/- warning: mul_equiv.comp_symm_eq -> MulEquiv.comp_symm_eq is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {α : Type.{u3}} (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (f : N -> α) (g : M -> α), Iff (Eq.{max (succ u2) (succ u3)} (N -> α) (Function.comp.{succ u2, succ u1, succ u3} N M α g (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e))) f) (Eq.{max (succ u1) (succ u3)} (M -> α) g (Function.comp.{succ u1, succ u2, succ u3} M N α f (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e)))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {α : Type.{u3}} (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (f : N -> α) (g : M -> α), Iff (Eq.{max (succ u1) (succ u3)} (N -> α) (Function.comp.{succ u1, succ u2, succ u3} N M α g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e))) f) (Eq.{max (succ u2) (succ u3)} (M -> α) g (Function.comp.{succ u2, succ u1, succ u3} M N α f (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e)))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.comp_symm_eq MulEquiv.comp_symm_eqₓ'. -/
 @[to_additive]
 theorem comp_symm_eq {α : Type _} (e : M ≃* N) (f : N → α) (g : M → α) :
     g ∘ e.symm = f ↔ g = f ∘ e :=
@@ -650,12 +460,6 @@ theorem comp_symm_eq {α : Type _} (e : M ≃* N) (f : N → α) (g : M → α)
 #align mul_equiv.comp_symm_eq MulEquiv.comp_symm_eq
 #align add_equiv.comp_symm_eq AddEquiv.comp_symm_eq
 
-/- warning: mul_equiv.eq_symm_comp -> MulEquiv.eq_symm_comp is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {α : Type.{u3}} (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (f : α -> M) (g : α -> N), Iff (Eq.{max (succ u3) (succ u1)} (α -> M) f (Function.comp.{succ u3, succ u2, succ u1} α N M (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e)) g)) (Eq.{max (succ u3) (succ u2)} (α -> N) (Function.comp.{succ u3, succ u1, succ u2} α M N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e) f) g)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {α : Type.{u3}} (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (f : α -> M) (g : α -> N), Iff (Eq.{max (succ u2) (succ u3)} (α -> M) f (Function.comp.{succ u3, succ u1, succ u2} α N M (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e)) g)) (Eq.{max (succ u1) (succ u3)} (α -> N) (Function.comp.{succ u3, succ u2, succ u1} α M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) f) g)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.eq_symm_comp MulEquiv.eq_symm_compₓ'. -/
 @[to_additive]
 theorem eq_symm_comp {α : Type _} (e : M ≃* N) (f : α → M) (g : α → N) :
     f = e.symm ∘ g ↔ e ∘ f = g :=
@@ -663,12 +467,6 @@ theorem eq_symm_comp {α : Type _} (e : M ≃* N) (f : α → M) (g : α → N)
 #align mul_equiv.eq_symm_comp MulEquiv.eq_symm_comp
 #align add_equiv.eq_symm_comp AddEquiv.eq_symm_comp
 
-/- warning: mul_equiv.symm_comp_eq -> MulEquiv.symm_comp_eq is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {α : Type.{u3}} (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (f : α -> M) (g : α -> N), Iff (Eq.{max (succ u3) (succ u1)} (α -> M) (Function.comp.{succ u3, succ u2, succ u1} α N M (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e)) g) f) (Eq.{max (succ u3) (succ u2)} (α -> N) g (Function.comp.{succ u3, succ u1, succ u2} α M N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e) f))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {α : Type.{u3}} (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (f : α -> M) (g : α -> N), Iff (Eq.{max (succ u2) (succ u3)} (α -> M) (Function.comp.{succ u3, succ u1, succ u2} α N M (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e)) g) f) (Eq.{max (succ u1) (succ u3)} (α -> N) g (Function.comp.{succ u3, succ u2, succ u1} α M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) f))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.symm_comp_eq MulEquiv.symm_comp_eqₓ'. -/
 @[to_additive]
 theorem symm_comp_eq {α : Type _} (e : M ≃* N) (f : α → M) (g : α → N) :
     e.symm ∘ g = f ↔ g = e ∘ f :=
@@ -676,48 +474,24 @@ theorem symm_comp_eq {α : Type _} (e : M ≃* N) (f : α → M) (g : α → N)
 #align mul_equiv.symm_comp_eq MulEquiv.symm_comp_eq
 #align add_equiv.symm_comp_eq AddEquiv.symm_comp_eq
 
-/- warning: mul_equiv.symm_trans_self -> MulEquiv.symm_trans_self is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2), Eq.{succ u2} (MulEquiv.{u2, u2} N N _inst_2 _inst_2) (MulEquiv.trans.{u2, u1, u2} N M N _inst_2 _inst_1 _inst_2 (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e) e) (MulEquiv.refl.{u2} N _inst_2)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{succ u1} (MulEquiv.{u1, u1} N N _inst_2 _inst_2) (MulEquiv.trans.{u1, u2, u1} N M N _inst_2 _inst_1 _inst_2 (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) e) (MulEquiv.refl.{u1} N _inst_2)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.symm_trans_self MulEquiv.symm_trans_selfₓ'. -/
 @[simp, to_additive]
 theorem symm_trans_self (e : M ≃* N) : e.symm.trans e = refl N :=
   FunLike.ext _ _ e.apply_symm_apply
 #align mul_equiv.symm_trans_self MulEquiv.symm_trans_self
 #align add_equiv.symm_trans_self AddEquiv.symm_trans_self
 
-/- warning: mul_equiv.self_trans_symm -> MulEquiv.self_trans_symm is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2), Eq.{succ u1} (MulEquiv.{u1, u1} M M _inst_1 _inst_1) (MulEquiv.trans.{u1, u2, u1} M N M _inst_1 _inst_2 _inst_1 e (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e)) (MulEquiv.refl.{u1} M _inst_1)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{succ u2} (MulEquiv.{u2, u2} M M _inst_1 _inst_1) (MulEquiv.trans.{u2, u1, u2} M N M _inst_1 _inst_2 _inst_1 e (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e)) (MulEquiv.refl.{u2} M _inst_1)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.self_trans_symm MulEquiv.self_trans_symmₓ'. -/
 @[simp, to_additive]
 theorem self_trans_symm (e : M ≃* N) : e.trans e.symm = refl M :=
   FunLike.ext _ _ e.symm_apply_apply
 #align mul_equiv.self_trans_symm MulEquiv.self_trans_symm
 #align add_equiv.self_trans_symm AddEquiv.self_trans_symm
 
-/- warning: mul_equiv.coe_monoid_hom_refl -> MulEquiv.coe_monoidHom_refl is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_5 : MulOneClass.{u1} M], Eq.{succ u1} (MonoidHom.{u1, u1} M M _inst_5 _inst_5) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (MulEquiv.{u1, u1} M M (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u1} M _inst_5)) (MonoidHom.{u1, u1} M M _inst_5 _inst_5) (HasLiftT.mk.{succ u1, succ u1} (MulEquiv.{u1, u1} M M (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u1} M _inst_5)) (MonoidHom.{u1, u1} M M _inst_5 _inst_5) (CoeTCₓ.coe.{succ u1, succ u1} (MulEquiv.{u1, u1} M M (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u1} M _inst_5)) (MonoidHom.{u1, u1} M M _inst_5 _inst_5) (MonoidHom.hasCoeT.{u1, u1, u1} M M (MulEquiv.{u1, u1} M M (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u1} M _inst_5)) _inst_5 _inst_5 (MulEquivClass.monoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} M M (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u1} M _inst_5)) M M _inst_5 _inst_5 (MulEquiv.mulEquivClass.{u1, u1} M M (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u1} M _inst_5)))))) (MulEquiv.refl.{u1} M (MulOneClass.toHasMul.{u1} M _inst_5))) (MonoidHom.id.{u1} M _inst_5)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_5 : MulOneClass.{u1} M], Eq.{succ u1} (MonoidHom.{u1, u1} M M _inst_5 _inst_5) (MonoidHomClass.toMonoidHom.{u1, u1, u1} M M (MulEquiv.{u1, u1} M M (MulOneClass.toMul.{u1} M _inst_5) (MulOneClass.toMul.{u1} M _inst_5)) _inst_5 _inst_5 (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} M M (MulOneClass.toMul.{u1} M _inst_5) (MulOneClass.toMul.{u1} M _inst_5)) M M _inst_5 _inst_5 (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} M M (MulOneClass.toMul.{u1} M _inst_5) (MulOneClass.toMul.{u1} M _inst_5))) (MulEquiv.refl.{u1} M (MulOneClass.toMul.{u1} M _inst_5))) (MonoidHom.id.{u1} M _inst_5)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.coe_monoid_hom_refl MulEquiv.coe_monoidHom_reflₓ'. -/
 @[to_additive, simp]
 theorem coe_monoidHom_refl {M} [MulOneClass M] : (refl M : M →* M) = MonoidHom.id M :=
   rfl
 #align mul_equiv.coe_monoid_hom_refl MulEquiv.coe_monoidHom_refl
 #align add_equiv.coe_add_monoid_hom_refl AddEquiv.coe_addMonoidHom_refl
 
-/- warning: mul_equiv.coe_monoid_hom_trans -> MulEquiv.coe_monoidHom_trans is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} {P : Type.{u3}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N] [_inst_7 : MulOneClass.{u3} P] (e₁ : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) (e₂ : MulEquiv.{u2, u3} N P (MulOneClass.toHasMul.{u2} N _inst_6) (MulOneClass.toHasMul.{u3} P _inst_7)), Eq.{max (succ u3) (succ u1)} (MonoidHom.{u1, u3} M P _inst_5 _inst_7) ((fun (a : Sort.{max (succ u1) (succ u3)}) (b : Sort.{max (succ u3) (succ u1)}) [self : HasLiftT.{max (succ u1) (succ u3), max (succ u3) (succ u1)} a b] => self.0) (MulEquiv.{u1, u3} M P (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u3} P _inst_7)) (MonoidHom.{u1, u3} M P _inst_5 _inst_7) (HasLiftT.mk.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (MulEquiv.{u1, u3} M P (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u3} P _inst_7)) (MonoidHom.{u1, u3} M P _inst_5 _inst_7) (CoeTCₓ.coe.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (MulEquiv.{u1, u3} M P (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u3} P _inst_7)) (MonoidHom.{u1, u3} M P _inst_5 _inst_7) (MonoidHom.hasCoeT.{u1, u3, max u1 u3} M P (MulEquiv.{u1, u3} M P (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u3} P _inst_7)) _inst_5 _inst_7 (MulEquivClass.monoidHomClass.{max u1 u3, u1, u3} (MulEquiv.{u1, u3} M P (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u3} P _inst_7)) M P _inst_5 _inst_7 (MulEquiv.mulEquivClass.{u1, u3} M P (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u3} P _inst_7)))))) (MulEquiv.trans.{u1, u2, u3} M N P (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6) (MulOneClass.toHasMul.{u3} P _inst_7) e₁ e₂)) (MonoidHom.comp.{u1, u2, u3} M N P _inst_5 _inst_6 _inst_7 ((fun (a : Sort.{max (succ u2) (succ u3)}) (b : Sort.{max (succ u3) (succ u2)}) [self : HasLiftT.{max (succ u2) (succ u3), max (succ u3) (succ u2)} a b] => self.0) (MulEquiv.{u2, u3} N P (MulOneClass.toHasMul.{u2} N _inst_6) (MulOneClass.toHasMul.{u3} P _inst_7)) (MonoidHom.{u2, u3} N P _inst_6 _inst_7) (HasLiftT.mk.{max (succ u2) (succ u3), max (succ u3) (succ u2)} (MulEquiv.{u2, u3} N P (MulOneClass.toHasMul.{u2} N _inst_6) (MulOneClass.toHasMul.{u3} P _inst_7)) (MonoidHom.{u2, u3} N P _inst_6 _inst_7) (CoeTCₓ.coe.{max (succ u2) (succ u3), max (succ u3) (succ u2)} (MulEquiv.{u2, u3} N P (MulOneClass.toHasMul.{u2} N _inst_6) (MulOneClass.toHasMul.{u3} P _inst_7)) (MonoidHom.{u2, u3} N P _inst_6 _inst_7) (MonoidHom.hasCoeT.{u2, u3, max u2 u3} N P (MulEquiv.{u2, u3} N P (MulOneClass.toHasMul.{u2} N _inst_6) (MulOneClass.toHasMul.{u3} P _inst_7)) _inst_6 _inst_7 (MulEquivClass.monoidHomClass.{max u2 u3, u2, u3} (MulEquiv.{u2, u3} N P (MulOneClass.toHasMul.{u2} N _inst_6) (MulOneClass.toHasMul.{u3} P _inst_7)) N P _inst_6 _inst_7 (MulEquiv.mulEquivClass.{u2, u3} N P (MulOneClass.toHasMul.{u2} N _inst_6) (MulOneClass.toHasMul.{u3} P _inst_7)))))) e₂) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max (succ u2) (succ u1)}) [self : HasLiftT.{max (succ u1) (succ u2), max (succ u2) (succ u1)} a b] => self.0) (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (HasLiftT.mk.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (CoeTCₓ.coe.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (MonoidHom.hasCoeT.{u1, u2, max u1 u2} M N (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) _inst_5 _inst_6 (MulEquivClass.monoidHomClass.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) M N _inst_5 _inst_6 (MulEquiv.mulEquivClass.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)))))) e₁))
-but is expected to have type
-  forall {M : Type.{u3}} {N : Type.{u2}} {P : Type.{u1}} [_inst_5 : MulOneClass.{u3} M] [_inst_6 : MulOneClass.{u2} N] [_inst_7 : MulOneClass.{u1} P] (e₁ : MulEquiv.{u3, u2} M N (MulOneClass.toMul.{u3} M _inst_5) (MulOneClass.toMul.{u2} N _inst_6)) (e₂ : MulEquiv.{u2, u1} N P (MulOneClass.toMul.{u2} N _inst_6) (MulOneClass.toMul.{u1} P _inst_7)), Eq.{max (succ u3) (succ u1)} (MonoidHom.{u3, u1} M P _inst_5 _inst_7) (MonoidHomClass.toMonoidHom.{u3, u1, max u3 u1} M P (MulEquiv.{u3, u1} M P (MulOneClass.toMul.{u3} M _inst_5) (MulOneClass.toMul.{u1} P _inst_7)) _inst_5 _inst_7 (MulEquivClass.instMonoidHomClass.{max u3 u1, u3, u1} (MulEquiv.{u3, u1} M P (MulOneClass.toMul.{u3} M _inst_5) (MulOneClass.toMul.{u1} P _inst_7)) M P _inst_5 _inst_7 (MulEquiv.instMulEquivClassMulEquiv.{u3, u1} M P (MulOneClass.toMul.{u3} M _inst_5) (MulOneClass.toMul.{u1} P _inst_7))) (MulEquiv.trans.{u3, u2, u1} M N P (MulOneClass.toMul.{u3} M _inst_5) (MulOneClass.toMul.{u2} N _inst_6) (MulOneClass.toMul.{u1} P _inst_7) e₁ e₂)) (MonoidHom.comp.{u3, u2, u1} M N P _inst_5 _inst_6 _inst_7 (MonoidHomClass.toMonoidHom.{u2, u1, max u2 u1} N P (MulEquiv.{u2, u1} N P (MulOneClass.toMul.{u2} N _inst_6) (MulOneClass.toMul.{u1} P _inst_7)) _inst_6 _inst_7 (MulEquivClass.instMonoidHomClass.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} N P (MulOneClass.toMul.{u2} N _inst_6) (MulOneClass.toMul.{u1} P _inst_7)) N P _inst_6 _inst_7 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} N P (MulOneClass.toMul.{u2} N _inst_6) (MulOneClass.toMul.{u1} P _inst_7))) e₂) (MonoidHomClass.toMonoidHom.{u3, u2, max u3 u2} M N (MulEquiv.{u3, u2} M N (MulOneClass.toMul.{u3} M _inst_5) (MulOneClass.toMul.{u2} N _inst_6)) _inst_5 _inst_6 (MulEquivClass.instMonoidHomClass.{max u3 u2, u3, u2} (MulEquiv.{u3, u2} M N (MulOneClass.toMul.{u3} M _inst_5) (MulOneClass.toMul.{u2} N _inst_6)) M N _inst_5 _inst_6 (MulEquiv.instMulEquivClassMulEquiv.{u3, u2} M N (MulOneClass.toMul.{u3} M _inst_5) (MulOneClass.toMul.{u2} N _inst_6))) e₁))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.coe_monoid_hom_trans MulEquiv.coe_monoidHom_transₓ'. -/
 @[to_additive, simp]
 theorem coe_monoidHom_trans {M N P} [MulOneClass M] [MulOneClass N] [MulOneClass P] (e₁ : M ≃* N)
     (e₂ : N ≃* P) : (e₁.trans e₂ : M →* P) = (e₂ : N →* P).comp ↑e₁ :=
@@ -725,12 +499,6 @@ theorem coe_monoidHom_trans {M N P} [MulOneClass M] [MulOneClass N] [MulOneClass
 #align mul_equiv.coe_monoid_hom_trans MulEquiv.coe_monoidHom_trans
 #align add_equiv.coe_add_monoid_hom_trans AddEquiv.coe_addMonoidHom_trans
 
-/- warning: mul_equiv.ext -> MulEquiv.ext is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {f : MulEquiv.{u1, u2} M N _inst_1 _inst_2} {g : MulEquiv.{u1, u2} M N _inst_1 _inst_2}, (forall (x : M), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) g x)) -> (Eq.{max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) f g)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {f : MulEquiv.{u2, u1} M N _inst_1 _inst_2} {g : MulEquiv.{u2, u1} M N _inst_1 _inst_2}, (forall (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) g x)) -> (Eq.{max (succ u2) (succ u1)} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) f g)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.ext MulEquiv.extₓ'. -/
 /-- Two multiplicative isomorphisms agree if they are defined by the
     same underlying function. -/
 @[ext,
@@ -741,54 +509,30 @@ theorem ext {f g : MulEquiv M N} (h : ∀ x, f x = g x) : f = g :=
 #align mul_equiv.ext MulEquiv.ext
 #align add_equiv.ext AddEquiv.ext
 
-/- warning: mul_equiv.ext_iff -> MulEquiv.ext_iff is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {f : MulEquiv.{u1, u2} M N _inst_1 _inst_2} {g : MulEquiv.{u1, u2} M N _inst_1 _inst_2}, Iff (Eq.{max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) f g) (forall (x : M), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) g x))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {f : MulEquiv.{u2, u1} M N _inst_1 _inst_2} {g : MulEquiv.{u2, u1} M N _inst_1 _inst_2}, Iff (Eq.{max (succ u2) (succ u1)} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) f g) (forall (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) g x))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.ext_iff MulEquiv.ext_iffₓ'. -/
 @[to_additive]
 theorem ext_iff {f g : MulEquiv M N} : f = g ↔ ∀ x, f x = g x :=
   FunLike.ext_iff
 #align mul_equiv.ext_iff MulEquiv.ext_iff
 #align add_equiv.ext_iff AddEquiv.ext_iff
 
-/- warning: mul_equiv.mk_coe -> MulEquiv.mk_coe is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align mul_equiv.mk_coe MulEquiv.mk_coeₓ'. -/
 @[simp, to_additive]
 theorem mk_coe (e : M ≃* N) (e' h₁ h₂ h₃) : (⟨e, e', h₁, h₂, h₃⟩ : M ≃* N) = e :=
   ext fun _ => rfl
 #align mul_equiv.mk_coe MulEquiv.mk_coe
 #align add_equiv.mk_coe AddEquiv.mk_coe
 
-/- warning: mul_equiv.mk_coe' -> MulEquiv.mk_coe' is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align mul_equiv.mk_coe' MulEquiv.mk_coe'ₓ'. -/
 @[simp, to_additive]
 theorem mk_coe' (e : M ≃* N) (f h₁ h₂ h₃) : (MulEquiv.mk f (⇑e) h₁ h₂ h₃ : N ≃* M) = e.symm :=
   symm_bijective.Injective <| ext fun x => rfl
 #align mul_equiv.mk_coe' MulEquiv.mk_coe'
 #align add_equiv.mk_coe' AddEquiv.mk_coe'
 
-/- warning: mul_equiv.congr_arg -> MulEquiv.congr_arg is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {f : MulEquiv.{u1, u2} M N _inst_1 _inst_2} {x : M} {x' : M}, (Eq.{succ u1} M x x') -> (Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f x'))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {f : MulEquiv.{u2, u1} M N _inst_1 _inst_2} {x : M} {x' : M}, (Eq.{succ u2} M x x') -> (Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f x'))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.congr_arg MulEquiv.congr_argₓ'. -/
 @[to_additive]
 protected theorem congr_arg {f : MulEquiv M N} {x x' : M} : x = x' → f x = f x' :=
   FunLike.congr_arg f
 #align mul_equiv.congr_arg MulEquiv.congr_arg
 #align add_equiv.congr_arg AddEquiv.congr_arg
 
-/- warning: mul_equiv.congr_fun -> MulEquiv.congr_fun is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {f : MulEquiv.{u1, u2} M N _inst_1 _inst_2} {g : MulEquiv.{u1, u2} M N _inst_1 _inst_2}, (Eq.{max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) f g) -> (forall (x : M), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) g x))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {f : MulEquiv.{u2, u1} M N _inst_1 _inst_2} {g : MulEquiv.{u2, u1} M N _inst_1 _inst_2}, (Eq.{max (succ u2) (succ u1)} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) f g) -> (forall (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) g x))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.congr_fun MulEquiv.congr_funₓ'. -/
 @[to_additive]
 protected theorem congr_fun {f g : MulEquiv M N} (h : f = g) (x : M) : f x = g x :=
   FunLike.congr_fun h x
@@ -817,12 +561,6 @@ instance {M N} [Unique M] [Unique N] [Mul M] [Mul N] : Unique (M ≃* N)
 -/
 
 
-/- warning: mul_equiv.map_one -> MulEquiv.map_one is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N] (h : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) (fun (_x : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) h (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M _inst_5))))) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N _inst_6))))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] (h : MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) (OfNat.ofNat.{u2} M 1 (One.toOfNat1.{u2} M (MulOneClass.toOne.{u2} M _inst_5)))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6))))) h (OfNat.ofNat.{u2} M 1 (One.toOfNat1.{u2} M (MulOneClass.toOne.{u2} M _inst_5)))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) (OfNat.ofNat.{u2} M 1 (One.toOfNat1.{u2} M (MulOneClass.toOne.{u2} M _inst_5)))) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) (OfNat.ofNat.{u2} M 1 (One.toOfNat1.{u2} M (MulOneClass.toOne.{u2} M _inst_5)))) (MulOneClass.toOne.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) (OfNat.ofNat.{u2} M 1 (One.toOfNat1.{u2} M (MulOneClass.toOne.{u2} M _inst_5)))) _inst_6)))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.map_one MulEquiv.map_oneₓ'. -/
 /-- A multiplicative isomorphism of monoids sends `1` to `1` (and is hence a monoid isomorphism). -/
 @[to_additive
       "An additive isomorphism of additive monoids sends `0` to `0`\n(and is hence an additive monoid isomorphism)."]
@@ -831,12 +569,6 @@ protected theorem map_one {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) :
 #align mul_equiv.map_one MulEquiv.map_one
 #align add_equiv.map_zero AddEquiv.map_zero
 
-/- warning: mul_equiv.map_eq_one_iff -> MulEquiv.map_eq_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N] (h : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) {x : M}, Iff (Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) (fun (_x : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) h x) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N _inst_6))))) (Eq.{succ u1} M x (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M _inst_5)))))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] (h : MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) {x : M}, Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6))))) h x) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (MulOneClass.toOne.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) _inst_6)))) (Eq.{succ u2} M x (OfNat.ofNat.{u2} M 1 (One.toOfNat1.{u2} M (MulOneClass.toOne.{u2} M _inst_5))))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.map_eq_one_iff MulEquiv.map_eq_one_iffₓ'. -/
 @[to_additive]
 protected theorem map_eq_one_iff {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) {x : M} :
     h x = 1 ↔ x = 1 :=
@@ -844,12 +576,6 @@ protected theorem map_eq_one_iff {M N} [MulOneClass M] [MulOneClass N] (h : M 
 #align mul_equiv.map_eq_one_iff MulEquiv.map_eq_one_iff
 #align add_equiv.map_eq_zero_iff AddEquiv.map_eq_zero_iff
 
-/- warning: mul_equiv.map_ne_one_iff -> MulEquiv.map_ne_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N] (h : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) {x : M}, Iff (Ne.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) (fun (_x : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) h x) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N _inst_6))))) (Ne.{succ u1} M x (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M _inst_5)))))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] (h : MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) {x : M}, Iff (Ne.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6))))) h x) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (MulOneClass.toOne.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) _inst_6)))) (Ne.{succ u2} M x (OfNat.ofNat.{u2} M 1 (One.toOfNat1.{u2} M (MulOneClass.toOne.{u2} M _inst_5))))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.map_ne_one_iff MulEquiv.map_ne_one_iffₓ'. -/
 @[to_additive]
 theorem map_ne_one_iff {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) {x : M} :
     h x ≠ 1 ↔ x ≠ 1 :=
@@ -867,24 +593,12 @@ noncomputable def ofBijective {M N F} [Mul M] [Mul N] [MulHomClass F M N] (f : F
 #align add_equiv.of_bijective AddEquiv.ofBijective
 -/
 
-/- warning: mul_equiv.of_bijective_apply_symm_apply -> MulEquiv.ofBijective_apply_symm_apply is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N] {n : N} (f : MonoidHom.{u1, u2} M N _inst_5 _inst_6) (hf : Function.Bijective.{succ u1, succ u2} M N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (fun (_x : MonoidHom.{u1, u2} M N _inst_5 _inst_6) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N _inst_5 _inst_6) f)), Eq.{succ u2} N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (fun (_x : MonoidHom.{u1, u2} M N _inst_5 _inst_6) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N _inst_5 _inst_6) f (coeFn.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2), max (succ u2) (succ u1)} (Equiv.{succ u2, succ u1} N M) (fun (_x : Equiv.{succ u2, succ u1} N M) => N -> M) (Equiv.hasCoeToFun.{succ u2, succ u1} N M) (Equiv.symm.{succ u1, succ u2} M N (Equiv.ofBijective.{succ u1, succ u2} M N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (fun (_x : MonoidHom.{u1, u2} M N _inst_5 _inst_6) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N _inst_5 _inst_6) f) hf)) n)) n
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] {n : N} (f : MonoidHom.{u2, u1} M N _inst_5 _inst_6) (hf : Function.Bijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f)), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} N M) N (fun (a : N) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : N) => M) a) (Equiv.instFunLikeEquiv.{succ u1, succ u2} N M) (Equiv.symm.{succ u2, succ u1} M N (Equiv.ofBijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (a : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f) hf)) n)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} N M) N (fun (_x : N) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : N) => M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} N M) (Equiv.symm.{succ u2, succ u1} M N (Equiv.ofBijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f) hf)) n)) n
-Case conversion may be inaccurate. Consider using '#align mul_equiv.of_bijective_apply_symm_apply MulEquiv.ofBijective_apply_symm_applyₓ'. -/
 @[simp]
 theorem ofBijective_apply_symm_apply {M N} [MulOneClass M] [MulOneClass N] {n : N} (f : M →* N)
     (hf : Function.Bijective f) : f ((Equiv.ofBijective f hf).symm n) = n :=
   (MulEquiv.ofBijective f hf).apply_symm_apply n
 #align mul_equiv.of_bijective_apply_symm_apply MulEquiv.ofBijective_apply_symm_apply
 
-/- warning: mul_equiv.to_monoid_hom -> MulEquiv.toMonoidHom is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N], (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) -> (MonoidHom.{u1, u2} M N _inst_5 _inst_6)
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N], (MulEquiv.{u1, u2} M N (MulOneClass.toMul.{u1} M _inst_5) (MulOneClass.toMul.{u2} N _inst_6)) -> (MonoidHom.{u1, u2} M N _inst_5 _inst_6)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.to_monoid_hom MulEquiv.toMonoidHomₓ'. -/
 /-- Extract the forward direction of a multiplicative equivalence
 as a multiplication-preserving function.
 -/
@@ -895,24 +609,12 @@ def toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) : M →* N
 #align mul_equiv.to_monoid_hom MulEquiv.toMonoidHom
 #align add_equiv.to_add_monoid_hom AddEquiv.toAddMonoidHom
 
-/- warning: mul_equiv.coe_to_monoid_hom -> MulEquiv.coe_toMonoidHom is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N] (e : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)), Eq.{max (succ u1) (succ u2)} (M -> N) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (fun (_x : MonoidHom.{u1, u2} M N _inst_5 _inst_6) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N _inst_5 _inst_6) (MulEquiv.toMonoidHom.{u1, u2} M N _inst_5 _inst_6 e)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) (fun (_x : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) e)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] (e : MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) (MulEquiv.toMonoidHom.{u2, u1} M N _inst_5 _inst_6 e)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6))))) e)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.coe_to_monoid_hom MulEquiv.coe_toMonoidHomₓ'. -/
 @[simp, to_additive]
 theorem coe_toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (e : M ≃* N) : ⇑e.toMonoidHom = e :=
   rfl
 #align mul_equiv.coe_to_monoid_hom MulEquiv.coe_toMonoidHom
 #align add_equiv.coe_to_add_monoid_hom AddEquiv.coe_toAddMonoidHom
 
-/- warning: mul_equiv.to_monoid_hom_injective -> MulEquiv.toMonoidHom_injective is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N], Function.Injective.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (MulEquiv.toMonoidHom.{u1, u2} M N _inst_5 _inst_6)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N], Function.Injective.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) (MonoidHom.{u2, u1} M N _inst_5 _inst_6) (MulEquiv.toMonoidHom.{u2, u1} M N _inst_5 _inst_6)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.to_monoid_hom_injective MulEquiv.toMonoidHom_injectiveₓ'. -/
 @[to_additive]
 theorem toMonoidHom_injective {M N} [MulOneClass M] [MulOneClass N] :
     Function.Injective (toMonoidHom : M ≃* N → M →* N) := fun f g h =>
@@ -938,12 +640,6 @@ def arrowCongr {M N P Q : Type _} [Mul P] [Mul Q] (f : M ≃ N) (g : P ≃* Q) :
 #align add_equiv.arrow_congr AddEquiv.arrowCongr
 -/
 
-/- warning: mul_equiv.monoid_hom_congr -> MulEquiv.monoidHomCongr is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} {P : Type.{u3}} {Q : Type.{u4}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N] [_inst_7 : CommMonoid.{u3} P] [_inst_8 : CommMonoid.{u4} Q], (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) -> (MulEquiv.{u3, u4} P Q (MulOneClass.toHasMul.{u3} P (Monoid.toMulOneClass.{u3} P (CommMonoid.toMonoid.{u3} P _inst_7))) (MulOneClass.toHasMul.{u4} Q (Monoid.toMulOneClass.{u4} Q (CommMonoid.toMonoid.{u4} Q _inst_8)))) -> (MulEquiv.{max u3 u1, max u4 u2} (MonoidHom.{u1, u3} M P _inst_5 (Monoid.toMulOneClass.{u3} P (CommMonoid.toMonoid.{u3} P _inst_7))) (MonoidHom.{u2, u4} N Q _inst_6 (Monoid.toMulOneClass.{u4} Q (CommMonoid.toMonoid.{u4} Q _inst_8))) (MonoidHom.hasMul.{u1, u3} M P _inst_5 _inst_7) (MonoidHom.hasMul.{u2, u4} N Q _inst_6 _inst_8))
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} {P : Type.{u3}} {Q : Type.{u4}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N] [_inst_7 : CommMonoid.{u3} P] [_inst_8 : CommMonoid.{u4} Q], (MulEquiv.{u1, u2} M N (MulOneClass.toMul.{u1} M _inst_5) (MulOneClass.toMul.{u2} N _inst_6)) -> (MulEquiv.{u3, u4} P Q (MulOneClass.toMul.{u3} P (Monoid.toMulOneClass.{u3} P (CommMonoid.toMonoid.{u3} P _inst_7))) (MulOneClass.toMul.{u4} Q (Monoid.toMulOneClass.{u4} Q (CommMonoid.toMonoid.{u4} Q _inst_8)))) -> (MulEquiv.{max u3 u1, max u4 u2} (MonoidHom.{u1, u3} M P _inst_5 (Monoid.toMulOneClass.{u3} P (CommMonoid.toMonoid.{u3} P _inst_7))) (MonoidHom.{u2, u4} N Q _inst_6 (Monoid.toMulOneClass.{u4} Q (CommMonoid.toMonoid.{u4} Q _inst_8))) (MonoidHom.mul.{u1, u3} M P _inst_5 _inst_7) (MonoidHom.mul.{u2, u4} N Q _inst_6 _inst_8))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.monoid_hom_congr MulEquiv.monoidHomCongrₓ'. -/
 /-- A multiplicative analogue of `equiv.arrow_congr`,
 for multiplicative maps from a monoid to a commutative monoid.
 -/
@@ -983,12 +679,6 @@ def piCongrRight {η : Type _} {Ms Ns : η → Type _} [∀ j, Mul (Ms j)] [∀
 #align add_equiv.Pi_congr_right AddEquiv.piCongrRight
 -/
 
-/- warning: mul_equiv.Pi_congr_right_refl -> MulEquiv.piCongrRight_refl is a dubious translation:
-lean 3 declaration is
-  forall {η : Type.{u1}} {Ms : η -> Type.{u2}} [_inst_5 : forall (j : η), Mul.{u2} (Ms j)], Eq.{succ (max u1 u2)} (MulEquiv.{max u1 u2, max u1 u2} (forall (j : η), Ms j) (forall (j : η), Ms j) (Pi.instMul.{u1, u2} η (fun (j : η) => Ms j) (fun (i : η) => _inst_5 i)) (Pi.instMul.{u1, u2} η (fun (j : η) => Ms j) (fun (i : η) => _inst_5 i))) (MulEquiv.piCongrRight.{u1, u2, u2} η (fun (j : η) => Ms j) (fun (j : η) => Ms j) (fun (j : η) => _inst_5 j) (fun (j : η) => _inst_5 j) (fun (j : η) => MulEquiv.refl.{u2} (Ms j) (_inst_5 j))) (MulEquiv.refl.{max u1 u2} (forall (j : η), Ms j) (Pi.instMul.{u1, u2} η (fun (j : η) => Ms j) (fun (i : η) => _inst_5 i)))
-but is expected to have type
-  forall {η : Type.{u2}} {Ms : η -> Type.{u1}} [_inst_5 : forall (j : η), Mul.{u1} (Ms j)], Eq.{max (succ u2) (succ u1)} (MulEquiv.{max u2 u1, max u2 u1} (forall (j : η), Ms j) (forall (j : η), Ms j) (Pi.instMul.{u2, u1} η (fun (j : η) => Ms j) (fun (i : η) => _inst_5 i)) (Pi.instMul.{u2, u1} η (fun (j : η) => Ms j) (fun (i : η) => _inst_5 i))) (MulEquiv.piCongrRight.{u2, u1, u1} η (fun (j : η) => Ms j) (fun (j : η) => Ms j) (fun (j : η) => _inst_5 j) (fun (j : η) => _inst_5 j) (fun (j : η) => MulEquiv.refl.{u1} (Ms j) (_inst_5 j))) (MulEquiv.refl.{max u2 u1} (forall (j : η), Ms j) (Pi.instMul.{u2, u1} η (fun (j : η) => Ms j) (fun (i : η) => _inst_5 i)))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.Pi_congr_right_refl MulEquiv.piCongrRight_reflₓ'. -/
 @[simp, to_additive]
 theorem piCongrRight_refl {η : Type _} {Ms : η → Type _} [∀ j, Mul (Ms j)] :
     (piCongrRight fun j => MulEquiv.refl (Ms j)) = MulEquiv.refl _ :=
@@ -996,12 +686,6 @@ theorem piCongrRight_refl {η : Type _} {Ms : η → Type _} [∀ j, Mul (Ms j)]
 #align mul_equiv.Pi_congr_right_refl MulEquiv.piCongrRight_refl
 #align add_equiv.Pi_congr_right_refl AddEquiv.piCongrRight_refl
 
-/- warning: mul_equiv.Pi_congr_right_symm -> MulEquiv.piCongrRight_symm is a dubious translation:
-lean 3 declaration is
-  forall {η : Type.{u1}} {Ms : η -> Type.{u2}} {Ns : η -> Type.{u3}} [_inst_5 : forall (j : η), Mul.{u2} (Ms j)] [_inst_6 : forall (j : η), Mul.{u3} (Ns j)] (es : forall (j : η), MulEquiv.{u2, u3} (Ms j) (Ns j) (_inst_5 j) (_inst_6 j)), Eq.{max (succ (max u1 u3)) (succ (max u1 u2))} (MulEquiv.{max u1 u3, max u1 u2} (forall (j : η), Ns j) (forall (j : η), Ms j) (Pi.instMul.{u1, u3} η (fun (j : η) => Ns j) (fun (i : η) => _inst_6 i)) (Pi.instMul.{u1, u2} η (fun (j : η) => Ms j) (fun (i : η) => _inst_5 i))) (MulEquiv.symm.{max u1 u2, max u1 u3} (forall (j : η), Ms j) (forall (j : η), Ns j) (Pi.instMul.{u1, u2} η (fun (j : η) => Ms j) (fun (i : η) => _inst_5 i)) (Pi.instMul.{u1, u3} η (fun (j : η) => Ns j) (fun (i : η) => _inst_6 i)) (MulEquiv.piCongrRight.{u1, u2, u3} η (fun (j : η) => Ms j) (fun (j : η) => Ns j) (fun (j : η) => _inst_5 j) (fun (j : η) => _inst_6 j) es)) (MulEquiv.piCongrRight.{u1, u3, u2} η (fun (j : η) => Ns j) (fun (j : η) => Ms j) (fun (i : η) => _inst_6 i) (fun (i : η) => _inst_5 i) (fun (i : η) => MulEquiv.symm.{u2, u3} (Ms i) (Ns i) (_inst_5 i) (_inst_6 i) (es i)))
-but is expected to have type
-  forall {η : Type.{u3}} {Ms : η -> Type.{u2}} {Ns : η -> Type.{u1}} [_inst_5 : forall (j : η), Mul.{u2} (Ms j)] [_inst_6 : forall (j : η), Mul.{u1} (Ns j)] (es : forall (j : η), MulEquiv.{u2, u1} (Ms j) (Ns j) (_inst_5 j) (_inst_6 j)), Eq.{max (max (succ u3) (succ u2)) (succ u1)} (MulEquiv.{max u3 u1, max u3 u2} (forall (j : η), Ns j) (forall (j : η), Ms j) (Pi.instMul.{u3, u1} η (fun (j : η) => Ns j) (fun (i : η) => _inst_6 i)) (Pi.instMul.{u3, u2} η (fun (j : η) => Ms j) (fun (i : η) => _inst_5 i))) (MulEquiv.symm.{max u3 u2, max u3 u1} (forall (j : η), Ms j) (forall (j : η), Ns j) (Pi.instMul.{u3, u2} η (fun (j : η) => Ms j) (fun (i : η) => _inst_5 i)) (Pi.instMul.{u3, u1} η (fun (j : η) => Ns j) (fun (i : η) => _inst_6 i)) (MulEquiv.piCongrRight.{u3, u2, u1} η (fun (j : η) => Ms j) (fun (j : η) => Ns j) (fun (j : η) => _inst_5 j) (fun (j : η) => _inst_6 j) es)) (MulEquiv.piCongrRight.{u3, u1, u2} η (fun (j : η) => Ns j) (fun (j : η) => Ms j) (fun (i : η) => _inst_6 i) (fun (i : η) => _inst_5 i) (fun (i : η) => MulEquiv.symm.{u2, u1} (Ms i) (Ns i) (_inst_5 i) (_inst_6 i) (es i)))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.Pi_congr_right_symm MulEquiv.piCongrRight_symmₓ'. -/
 @[simp, to_additive]
 theorem piCongrRight_symm {η : Type _} {Ms Ns : η → Type _} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
     (es : ∀ j, Ms j ≃* Ns j) : (piCongrRight es).symm = piCongrRight fun i => (es i).symm :=
@@ -1009,12 +693,6 @@ theorem piCongrRight_symm {η : Type _} {Ms Ns : η → Type _} [∀ j, Mul (Ms
 #align mul_equiv.Pi_congr_right_symm MulEquiv.piCongrRight_symm
 #align add_equiv.Pi_congr_right_symm AddEquiv.piCongrRight_symm
 
-/- warning: mul_equiv.Pi_congr_right_trans -> MulEquiv.piCongrRight_trans is a dubious translation:
-lean 3 declaration is
-  forall {η : Type.{u1}} {Ms : η -> Type.{u2}} {Ns : η -> Type.{u3}} {Ps : η -> Type.{u4}} [_inst_5 : forall (j : η), Mul.{u2} (Ms j)] [_inst_6 : forall (j : η), Mul.{u3} (Ns j)] [_inst_7 : forall (j : η), Mul.{u4} (Ps j)] (es : forall (j : η), MulEquiv.{u2, u3} (Ms j) (Ns j) (_inst_5 j) (_inst_6 j)) (fs : forall (j : η), MulEquiv.{u3, u4} (Ns j) (Ps j) (_inst_6 j) (_inst_7 j)), Eq.{max (succ (max u1 u2)) (succ (max u1 u4))} (MulEquiv.{max u1 u2, max u1 u4} (forall (j : η), Ms j) (forall (j : η), Ps j) (Pi.instMul.{u1, u2} η (fun (j : η) => Ms j) (fun (i : η) => _inst_5 i)) (Pi.instMul.{u1, u4} η (fun (j : η) => Ps j) (fun (i : η) => _inst_7 i))) (MulEquiv.trans.{max u1 u2, max u1 u3, max u1 u4} (forall (j : η), Ms j) (forall (j : η), Ns j) (forall (j : η), Ps j) (Pi.instMul.{u1, u2} η (fun (j : η) => Ms j) (fun (i : η) => _inst_5 i)) (Pi.instMul.{u1, u3} η (fun (j : η) => Ns j) (fun (i : η) => _inst_6 i)) (Pi.instMul.{u1, u4} η (fun (j : η) => Ps j) (fun (i : η) => _inst_7 i)) (MulEquiv.piCongrRight.{u1, u2, u3} η (fun (j : η) => Ms j) (fun (j : η) => Ns j) (fun (j : η) => _inst_5 j) (fun (j : η) => _inst_6 j) es) (MulEquiv.piCongrRight.{u1, u3, u4} η (fun (j : η) => Ns j) (fun (j : η) => Ps j) (fun (i : η) => _inst_6 i) (fun (j : η) => _inst_7 j) fs)) (MulEquiv.piCongrRight.{u1, u2, u4} η (fun (j : η) => Ms j) (fun (j : η) => Ps j) (fun (i : η) => _inst_5 i) (fun (i : η) => _inst_7 i) (fun (i : η) => MulEquiv.trans.{u2, u3, u4} (Ms i) (Ns i) (Ps i) (_inst_5 i) (_inst_6 i) (_inst_7 i) (es i) (fs i)))
-but is expected to have type
-  forall {η : Type.{u4}} {Ms : η -> Type.{u3}} {Ns : η -> Type.{u2}} {Ps : η -> Type.{u1}} [_inst_5 : forall (j : η), Mul.{u3} (Ms j)] [_inst_6 : forall (j : η), Mul.{u2} (Ns j)] [_inst_7 : forall (j : η), Mul.{u1} (Ps j)] (es : forall (j : η), MulEquiv.{u3, u2} (Ms j) (Ns j) (_inst_5 j) (_inst_6 j)) (fs : forall (j : η), MulEquiv.{u2, u1} (Ns j) (Ps j) (_inst_6 j) (_inst_7 j)), Eq.{max (max (succ u4) (succ u3)) (succ u1)} (MulEquiv.{max u4 u3, max u4 u1} (forall (j : η), Ms j) (forall (j : η), Ps j) (Pi.instMul.{u4, u3} η (fun (j : η) => Ms j) (fun (i : η) => _inst_5 i)) (Pi.instMul.{u4, u1} η (fun (j : η) => Ps j) (fun (i : η) => _inst_7 i))) (MulEquiv.trans.{max u4 u3, max u4 u2, max u4 u1} (forall (j : η), Ms j) (forall (j : η), Ns j) (forall (j : η), Ps j) (Pi.instMul.{u4, u3} η (fun (j : η) => Ms j) (fun (i : η) => _inst_5 i)) (Pi.instMul.{u4, u2} η (fun (j : η) => Ns j) (fun (i : η) => _inst_6 i)) (Pi.instMul.{u4, u1} η (fun (j : η) => Ps j) (fun (i : η) => _inst_7 i)) (MulEquiv.piCongrRight.{u4, u3, u2} η (fun (j : η) => Ms j) (fun (j : η) => Ns j) (fun (j : η) => _inst_5 j) (fun (j : η) => _inst_6 j) es) (MulEquiv.piCongrRight.{u4, u2, u1} η (fun (j : η) => Ns j) (fun (j : η) => Ps j) (fun (i : η) => _inst_6 i) (fun (j : η) => _inst_7 j) fs)) (MulEquiv.piCongrRight.{u4, u3, u1} η (fun (j : η) => Ms j) (fun (j : η) => Ps j) (fun (i : η) => _inst_5 i) (fun (i : η) => _inst_7 i) (fun (i : η) => MulEquiv.trans.{u3, u2, u1} (Ms i) (Ns i) (Ps i) (_inst_5 i) (_inst_6 i) (_inst_7 i) (es i) (fs i)))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.Pi_congr_right_trans MulEquiv.piCongrRight_transₓ'. -/
 @[simp, to_additive]
 theorem piCongrRight_trans {η : Type _} {Ms Ns Ps : η → Type _} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
     [∀ j, Mul (Ps j)] (es : ∀ j, Ms j ≃* Ns j) (fs : ∀ j, Ns j ≃* Ps j) :
@@ -1041,12 +719,6 @@ def piSubsingleton {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)] [Subsing
 -/
 
 
-/- warning: mul_equiv.map_inv -> MulEquiv.map_inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_5 : Group.{u1} G] [_inst_6 : DivisionMonoid.{u2} H] (h : MulEquiv.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) (x : G), Eq.{succ u2} H (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) (fun (_x : MulEquiv.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) => G -> H) (MulEquiv.hasCoeToFun.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) h (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)) x)) (Inv.inv.{u2} H (DivInvMonoid.toHasInv.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) (fun (_x : MulEquiv.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) => G -> H) (MulEquiv.hasCoeToFun.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) h x))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_5 : Group.{u2} G] [_inst_6 : DivisionMonoid.{u1} H] (h : MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) (x : G), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_5)))) x)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G (fun (_x : G) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G H (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G H (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6)))) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6)))))))) h (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_5)))) x)) (Inv.inv.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) x) (InvOneClass.toInv.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) x) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) x) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) x) _inst_6))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G (fun (_x : G) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G H (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G H (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6)))) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6)))))))) h x))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.map_inv MulEquiv.map_invₓ'. -/
 /-- A multiplicative equivalence of groups preserves inversion. -/
 @[to_additive "An additive equivalence of additive groups preserves negation."]
 protected theorem map_inv [Group G] [DivisionMonoid H] (h : G ≃* H) (x : G) : h x⁻¹ = (h x)⁻¹ :=
@@ -1054,9 +726,6 @@ protected theorem map_inv [Group G] [DivisionMonoid H] (h : G ≃* H) (x : G) :
 #align mul_equiv.map_inv MulEquiv.map_inv
 #align add_equiv.map_neg AddEquiv.map_neg
 
-/- warning: mul_equiv.map_div -> MulEquiv.map_div is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align mul_equiv.map_div MulEquiv.map_divₓ'. -/
 /-- A multiplicative equivalence of groups preserves division. -/
 @[to_additive "An additive equivalence of additive groups preserves subtractions."]
 protected theorem map_div [Group G] [DivisionMonoid H] (h : G ≃* H) (x y : G) :
@@ -1087,12 +756,6 @@ def MulHom.toMulEquiv [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M) (h₁
 #align add_hom.to_add_equiv AddHom.toAddEquiv
 -/
 
-/- warning: monoid_hom.to_mul_equiv -> MonoidHom.toMulEquiv is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : MulOneClass.{u1} M] [_inst_2 : MulOneClass.{u2} N] (f : MonoidHom.{u1, u2} M N _inst_1 _inst_2) (g : MonoidHom.{u2, u1} N M _inst_2 _inst_1), (Eq.{succ u1} (MonoidHom.{u1, u1} M M _inst_1 _inst_1) (MonoidHom.comp.{u1, u2, u1} M N M _inst_1 _inst_2 _inst_1 g f) (MonoidHom.id.{u1} M _inst_1)) -> (Eq.{succ u2} (MonoidHom.{u2, u2} N N _inst_2 _inst_2) (MonoidHom.comp.{u2, u1, u2} N M N _inst_2 _inst_1 _inst_2 f g) (MonoidHom.id.{u2} N _inst_2)) -> (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_1) (MulOneClass.toHasMul.{u2} N _inst_2))
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : MulOneClass.{u1} M] [_inst_2 : MulOneClass.{u2} N] (f : MonoidHom.{u1, u2} M N _inst_1 _inst_2) (g : MonoidHom.{u2, u1} N M _inst_2 _inst_1), (Eq.{succ u1} (MonoidHom.{u1, u1} M M _inst_1 _inst_1) (MonoidHom.comp.{u1, u2, u1} M N M _inst_1 _inst_2 _inst_1 g f) (MonoidHom.id.{u1} M _inst_1)) -> (Eq.{succ u2} (MonoidHom.{u2, u2} N N _inst_2 _inst_2) (MonoidHom.comp.{u2, u1, u2} N M N _inst_2 _inst_1 _inst_2 f g) (MonoidHom.id.{u2} N _inst_2)) -> (MulEquiv.{u1, u2} M N (MulOneClass.toMul.{u1} M _inst_1) (MulOneClass.toMul.{u2} N _inst_2))
-Case conversion may be inaccurate. Consider using '#align monoid_hom.to_mul_equiv MonoidHom.toMulEquivₓ'. -/
 /-- Given a pair of monoid homomorphisms `f`, `g` such that `g.comp f = id` and `f.comp g = id`,
 returns an multiplicative equivalence with `to_fun = f` and `inv_fun = g`.  This constructor is
 useful if the underlying type(s) have specialized `ext` lemmas for monoid homomorphisms. -/

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -164,9 +164,7 @@ instance (priority := 100) toMonoidWithZeroHomClass {α β : Type _} [MulZeroOne
     map_zero := fun e =>
       calc
         e 0 = e 0 * e (EquivLike.inv e 0) := by rw [← map_mul, MulZeroClass.zero_mul]
-        _ = 0 := by
-          convert MulZeroClass.mul_zero _
-          exact EquivLike.right_inv e _
+        _ = 0 := by convert MulZeroClass.mul_zero _; exact EquivLike.right_inv e _
          }
 #align mul_equiv_class.to_monoid_with_zero_hom_class MulEquivClass.toMonoidWithZeroHomClass
 
@@ -222,10 +220,7 @@ instance [Mul M] [Mul N] : MulEquivClass (M ≃* N) M N
   inv := invFun
   left_inv := left_inv
   right_inv := right_inv
-  coe_injective' f g h₁ h₂ := by
-    cases f
-    cases g
-    congr
+  coe_injective' f g h₁ h₂ := by cases f; cases g; congr
   map_mul := map_mul'
 
 variable [Mul M] [Mul N] [Mul P] [Mul Q]
@@ -936,15 +931,9 @@ def arrowCongr {M N P Q : Type _} [Mul P] [Mul Q] (f : M ≃ N) (g : P ≃* Q) :
     where
   toFun h n := g (h (f.symm n))
   invFun k m := g.symm (k (f m))
-  left_inv h := by
-    ext
-    simp
-  right_inv k := by
-    ext
-    simp
-  map_mul' h k := by
-    ext
-    simp
+  left_inv h := by ext; simp
+  right_inv k := by ext; simp
+  map_mul' h k := by ext; simp
 #align mul_equiv.arrow_congr MulEquiv.arrowCongr
 #align add_equiv.arrow_congr AddEquiv.arrowCongr
 -/
@@ -966,15 +955,9 @@ def monoidHomCongr {M N P Q} [MulOneClass M] [MulOneClass N] [CommMonoid P] [Com
     where
   toFun h := g.toMonoidHom.comp (h.comp f.symm.toMonoidHom)
   invFun k := g.symm.toMonoidHom.comp (k.comp f.toMonoidHom)
-  left_inv h := by
-    ext
-    simp
-  right_inv k := by
-    ext
-    simp
-  map_mul' h k := by
-    ext
-    simp
+  left_inv h := by ext; simp
+  right_inv k := by ext; simp
+  map_mul' h k := by ext; simp
 #align mul_equiv.monoid_hom_congr MulEquiv.monoidHomCongr
 #align add_equiv.add_monoid_hom_congr AddEquiv.addMonoidHomCongr

bump to nightly-2023-05-28-03

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

6c6011cf

Diff

@@ -759,10 +759,7 @@ theorem ext_iff {f g : MulEquiv M N} : f = g ↔ ∀ x, f x = g x :=
 #align add_equiv.ext_iff AddEquiv.ext_iff
 
 /- warning: mul_equiv.mk_coe -> MulEquiv.mk_coe is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (e' : N -> M) (h₁ : Function.LeftInverse.{succ u1, succ u2} M N e' (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e)) (h₂ : Function.RightInverse.{succ u1, succ u2} M N e' (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e)) (h₃ : forall (x : M) (y : M), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x y)) (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N _inst_2) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e y))), Eq.{max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (MulEquiv.mk.{u1, u2} M N _inst_1 _inst_2 (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e) e' h₁ h₂ h₃) e
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (e' : N -> M) (h₁ : Function.LeftInverse.{succ u2, succ u1} M N e' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e)) (h₂ : Function.RightInverse.{succ u2, succ u1} M N e' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e)) (h₃ : forall (x : M) (y : M), Eq.{succ u1} N (Equiv.toFun.{succ u2, succ u1} M N (Equiv.mk.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (a : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) e' h₁ h₂) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M _inst_1) x y)) (HMul.hMul.{u1, u1, u1} N N N (instHMul.{u1} N _inst_2) (Equiv.toFun.{succ u2, succ u1} M N (Equiv.mk.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (a : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) e' h₁ h₂) x) (Equiv.toFun.{succ u2, succ u1} M N (Equiv.mk.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (a : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) e' h₁ h₂) y))), Eq.{max (succ u2) (succ u1)} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) (MulEquiv.mk.{u2, u1} M N _inst_1 _inst_2 (Equiv.mk.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (a : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) e' h₁ h₂) h₃) e
+<too large>
 Case conversion may be inaccurate. Consider using '#align mul_equiv.mk_coe MulEquiv.mk_coeₓ'. -/
 @[simp, to_additive]
 theorem mk_coe (e : M ≃* N) (e' h₁ h₂ h₃) : (⟨e, e', h₁, h₂, h₃⟩ : M ≃* N) = e :=
@@ -771,10 +768,7 @@ theorem mk_coe (e : M ≃* N) (e' h₁ h₂ h₃) : (⟨e, e', h₁, h₂, h₃
 #align add_equiv.mk_coe AddEquiv.mk_coe
 
 /- warning: mul_equiv.mk_coe' -> MulEquiv.mk_coe' is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (f : N -> M) (h₁ : Function.LeftInverse.{succ u2, succ u1} N M (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e) f) (h₂ : Function.RightInverse.{succ u2, succ u1} N M (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e) f) (h₃ : forall (x : N) (y : N), Eq.{succ u1} M (f (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N _inst_2) x y)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) (f x) (f y))), Eq.{max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.mk.{u2, u1} N M _inst_2 _inst_1 f (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e) h₁ h₂ h₃) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (f : N -> M) (h₁ : Function.LeftInverse.{succ u1, succ u2} N M (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (e : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) e) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) f) (h₂ : Function.RightInverse.{succ u1, succ u2} N M (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (e : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) e) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) f) (h₃ : forall (x : N) (y : N), Eq.{succ u2} M (Equiv.toFun.{succ u1, succ u2} N M (Equiv.mk.{succ u1, succ u2} N M f (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (a : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) h₁ h₂) (HMul.hMul.{u1, u1, u1} N N N (instHMul.{u1} N _inst_2) x y)) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M _inst_1) (Equiv.toFun.{succ u1, succ u2} N M (Equiv.mk.{succ u1, succ u2} N M f (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (a : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) h₁ h₂) x) (Equiv.toFun.{succ u1, succ u2} N M (Equiv.mk.{succ u1, succ u2} N M f (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (a : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) h₁ h₂) y))), Eq.{max (succ u2) (succ u1)} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) (MulEquiv.mk.{u1, u2} N M _inst_2 _inst_1 (Equiv.mk.{succ u1, succ u2} N M f (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (a : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) h₁ h₂) h₃) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e)
+<too large>
 Case conversion may be inaccurate. Consider using '#align mul_equiv.mk_coe' MulEquiv.mk_coe'ₓ'. -/
 @[simp, to_additive]
 theorem mk_coe' (e : M ≃* N) (f h₁ h₂ h₃) : (MulEquiv.mk f (⇑e) h₁ h₂ h₃ : N ≃* M) = e.symm :=
@@ -1078,10 +1072,7 @@ protected theorem map_inv [Group G] [DivisionMonoid H] (h : G ≃* H) (x : G) :
 #align add_equiv.map_neg AddEquiv.map_neg
 
 /- warning: mul_equiv.map_div -> MulEquiv.map_div is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_5 : Group.{u1} G] [_inst_6 : DivisionMonoid.{u2} H] (h : MulEquiv.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) (x : G) (y : G), Eq.{succ u2} H (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) (fun (_x : MulEquiv.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) => G -> H) (MulEquiv.hasCoeToFun.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) h (HDiv.hDiv.{u1, u1, u1} G G G (instHDiv.{u1} G (DivInvMonoid.toHasDiv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5))) x y)) (HDiv.hDiv.{u2, u2, u2} H H H (instHDiv.{u2} H (DivInvMonoid.toHasDiv.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) (fun (_x : MulEquiv.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) => G -> H) (MulEquiv.hasCoeToFun.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) h x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) (fun (_x : MulEquiv.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) => G -> H) (MulEquiv.hasCoeToFun.{u1, u2} G H (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_5)))) (MulOneClass.toHasMul.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (DivisionMonoid.toDivInvMonoid.{u2} H _inst_6))))) h y))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_5 : Group.{u2} G] [_inst_6 : DivisionMonoid.{u1} H] (h : MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) (x : G) (y : G), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) (HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5))) x y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G (fun (_x : G) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G H (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G H (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6)))) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6)))))))) h (HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5))) x y)) (HDiv.hDiv.{u1, u1, u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) x) ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) y) ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) x) (instHDiv.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) x) (DivInvMonoid.toDiv.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) x) (DivisionMonoid.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) x) _inst_6))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G (fun (_x : G) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G H (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G H (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6)))) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6)))))))) h x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G (fun (_x : G) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => H) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G H (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G H (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6))))) G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6)))) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} G H (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_5)))) (MulOneClass.toMul.{u1} H (Monoid.toMulOneClass.{u1} H (DivInvMonoid.toMonoid.{u1} H (DivisionMonoid.toDivInvMonoid.{u1} H _inst_6)))))))) h y))
+<too large>
 Case conversion may be inaccurate. Consider using '#align mul_equiv.map_div MulEquiv.map_divₓ'. -/
 /-- A multiplicative equivalence of groups preserves division. -/
 @[to_additive "An additive equivalence of additive groups preserves subtractions."]

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -64,7 +64,7 @@ def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M) (h₁ : Funct
 lean 3 declaration is
   forall {A : Type.{u1}} {B : Type.{u2}} [_inst_1 : Monoid.{u1} A] [_inst_2 : Monoid.{u2} B] (f : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (g : B -> A), (Function.LeftInverse.{succ u1, succ u2} A B g (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (fun (_x : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) => A -> B) (MonoidHom.hasCoeToFun.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) f)) -> (Function.RightInverse.{succ u1, succ u2} A B g (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (fun (_x : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) => A -> B) (MonoidHom.hasCoeToFun.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) f)) -> (MonoidHom.{u2, u1} B A (Monoid.toMulOneClass.{u2} B _inst_2) (Monoid.toMulOneClass.{u1} A _inst_1))
 but is expected to have type
-  forall {A : Type.{u1}} {B : Type.{u2}} [_inst_1 : Monoid.{u1} A] [_inst_2 : Monoid.{u2} B] (f : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (g : B -> A), (Function.LeftInverse.{succ u1, succ u2} A B g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : A) => B) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (MulOneClass.toMul.{u1} A (Monoid.toMulOneClass.{u1} A _inst_1)) (MulOneClass.toMul.{u2} B (Monoid.toMulOneClass.{u2} B _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2) (MonoidHom.monoidHomClass.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)))) f)) -> (Function.RightInverse.{succ u1, succ u2} A B g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : A) => B) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (MulOneClass.toMul.{u1} A (Monoid.toMulOneClass.{u1} A _inst_1)) (MulOneClass.toMul.{u2} B (Monoid.toMulOneClass.{u2} B _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2) (MonoidHom.monoidHomClass.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)))) f)) -> (MonoidHom.{u2, u1} B A (Monoid.toMulOneClass.{u2} B _inst_2) (Monoid.toMulOneClass.{u1} A _inst_1))
+  forall {A : Type.{u1}} {B : Type.{u2}} [_inst_1 : Monoid.{u1} A] [_inst_2 : Monoid.{u2} B] (f : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (g : B -> A), (Function.LeftInverse.{succ u1, succ u2} A B g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : A) => B) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (MulOneClass.toMul.{u1} A (Monoid.toMulOneClass.{u1} A _inst_1)) (MulOneClass.toMul.{u2} B (Monoid.toMulOneClass.{u2} B _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2) (MonoidHom.monoidHomClass.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)))) f)) -> (Function.RightInverse.{succ u1, succ u2} A B g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : A) => B) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (MulOneClass.toMul.{u1} A (Monoid.toMulOneClass.{u1} A _inst_1)) (MulOneClass.toMul.{u2} B (Monoid.toMulOneClass.{u2} B _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2) (MonoidHom.monoidHomClass.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)))) f)) -> (MonoidHom.{u2, u1} B A (Monoid.toMulOneClass.{u2} B _inst_2) (Monoid.toMulOneClass.{u1} A _inst_1))
 Case conversion may be inaccurate. Consider using '#align monoid_hom.inverse MonoidHom.inverseₓ'. -/
 /-- The inverse of a bijective `monoid_hom` is a `monoid_hom`. -/
 @[to_additive "The inverse of a bijective `add_monoid_hom` is an `add_monoid_hom`.", simps]
@@ -258,7 +258,7 @@ theorem [anonymous] {f : M ≃* N} : f.toFun = f :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {f : MulEquiv.{u1, u2} M N _inst_1 _inst_2}, Eq.{max (succ u1) (succ u2)} (M -> N) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} M N) (fun (_x : Equiv.{succ u1, succ u2} M N) => M -> N) (Equiv.hasCoeToFun.{succ u1, succ u2} M N) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)}) [self : HasLiftT.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} a b] => self.0) (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (HasLiftT.mk.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (CoeTCₓ.coe.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (Equiv.hasCoeT.{succ u1, succ u2, max (succ u1) (succ u2)} M N (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.mulEquivClass.{u1, u2} M N _inst_1 _inst_2))))) f)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (f : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} M N) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => N) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} M N) (EquivLike.toEquiv.{succ u2, succ u1, max (succ u2) (succ u1)} M N (MulEquiv.{u2, u1} M N _inst_1 _inst_2) (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)) f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (f : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} M N) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => N) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} M N) (EquivLike.toEquiv.{succ u2, succ u1, max (succ u2) (succ u1)} M N (MulEquiv.{u2, u1} M N _inst_1 _inst_2) (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)) f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.coe_to_equiv MulEquiv.coe_toEquivₓ'. -/
 @[simp, to_additive]
 theorem coe_toEquiv {f : M ≃* N} : ⇑(f : M ≃ N) = f :=
@@ -270,7 +270,7 @@ theorem coe_toEquiv {f : M ≃* N} : ⇑(f : M ≃ N) = f :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {f : MulEquiv.{u1, u2} M N _inst_1 _inst_2}, Eq.{max (succ u1) (succ u2)} (M -> N) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulHom.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) (MulEquiv.toMulHom.{u1, u2} M N _inst_1 _inst_2 f)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {f : MulEquiv.{u2, u1} M N _inst_1 _inst_2}, Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulHom.mulHomClass.{u2, u1} M N _inst_1 _inst_2)) (MulEquiv.toMulHom.{u2, u1} M N _inst_1 _inst_2 f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {f : MulEquiv.{u2, u1} M N _inst_1 _inst_2}, Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulHom.mulHomClass.{u2, u1} M N _inst_1 _inst_2)) (MulEquiv.toMulHom.{u2, u1} M N _inst_1 _inst_2 f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.coe_to_mul_hom MulEquiv.coe_toMulHomₓ'. -/
 @[simp, to_additive]
 theorem coe_toMulHom {f : M ≃* N} : ⇑f.toMulHom = f :=
@@ -882,7 +882,7 @@ noncomputable def ofBijective {M N F} [Mul M] [Mul N] [MulHomClass F M N] (f : F
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N] {n : N} (f : MonoidHom.{u1, u2} M N _inst_5 _inst_6) (hf : Function.Bijective.{succ u1, succ u2} M N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (fun (_x : MonoidHom.{u1, u2} M N _inst_5 _inst_6) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N _inst_5 _inst_6) f)), Eq.{succ u2} N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (fun (_x : MonoidHom.{u1, u2} M N _inst_5 _inst_6) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N _inst_5 _inst_6) f (coeFn.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2), max (succ u2) (succ u1)} (Equiv.{succ u2, succ u1} N M) (fun (_x : Equiv.{succ u2, succ u1} N M) => N -> M) (Equiv.hasCoeToFun.{succ u2, succ u1} N M) (Equiv.symm.{succ u1, succ u2} M N (Equiv.ofBijective.{succ u1, succ u2} M N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (fun (_x : MonoidHom.{u1, u2} M N _inst_5 _inst_6) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N _inst_5 _inst_6) f) hf)) n)) n
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] {n : N} (f : MonoidHom.{u2, u1} M N _inst_5 _inst_6) (hf : Function.Bijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f)), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} N M) N (fun (a : N) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : N) => M) a) (Equiv.instFunLikeEquiv.{succ u1, succ u2} N M) (Equiv.symm.{succ u2, succ u1} M N (Equiv.ofBijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (a : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f) hf)) n)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} N M) N (fun (_x : N) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : N) => M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} N M) (Equiv.symm.{succ u2, succ u1} M N (Equiv.ofBijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f) hf)) n)) n
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] {n : N} (f : MonoidHom.{u2, u1} M N _inst_5 _inst_6) (hf : Function.Bijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f)), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} N M) N (fun (a : N) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : N) => M) a) (Equiv.instFunLikeEquiv.{succ u1, succ u2} N M) (Equiv.symm.{succ u2, succ u1} M N (Equiv.ofBijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (a : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f) hf)) n)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} N M) N (fun (_x : N) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : N) => M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} N M) (Equiv.symm.{succ u2, succ u1} M N (Equiv.ofBijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f) hf)) n)) n
 Case conversion may be inaccurate. Consider using '#align mul_equiv.of_bijective_apply_symm_apply MulEquiv.ofBijective_apply_symm_applyₓ'. -/
 @[simp]
 theorem ofBijective_apply_symm_apply {M N} [MulOneClass M] [MulOneClass N] {n : N} (f : M →* N)
@@ -910,7 +910,7 @@ def toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) : M →* N
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N] (e : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)), Eq.{max (succ u1) (succ u2)} (M -> N) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (fun (_x : MonoidHom.{u1, u2} M N _inst_5 _inst_6) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N _inst_5 _inst_6) (MulEquiv.toMonoidHom.{u1, u2} M N _inst_5 _inst_6 e)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) (fun (_x : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) e)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] (e : MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) (MulEquiv.toMonoidHom.{u2, u1} M N _inst_5 _inst_6 e)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6))))) e)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] (e : MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) (MulEquiv.toMonoidHom.{u2, u1} M N _inst_5 _inst_6 e)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6))))) e)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.coe_to_monoid_hom MulEquiv.coe_toMonoidHomₓ'. -/
 @[simp, to_additive]
 theorem coe_toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (e : M ≃* N) : ⇑e.toMonoidHom = e :=

bump to nightly-2023-05-16-14

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

b356e20f

Diff

@@ -363,7 +363,7 @@ def symm (h : M ≃* N) : N ≃* M :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {f : MulEquiv.{u1, u2} M N _inst_1 _inst_2}, Eq.{max (succ u2) (succ u1)} (N -> M) (MulEquiv.invFun.{u1, u2} M N _inst_1 _inst_2 f) (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 f))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {f : MulEquiv.{u2, u1} M N _inst_1 _inst_2}, Eq.{max (succ u2) (succ u1)} (N -> M) (Equiv.invFun.{succ u2, succ u1} M N (MulEquiv.toEquiv.{u2, u1} M N _inst_1 _inst_2 f)) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u2 u1, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 f))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {f : MulEquiv.{u2, u1} M N _inst_1 _inst_2}, Eq.{max (succ u2) (succ u1)} (N -> M) (Equiv.invFun.{succ u2, succ u1} M N (MulEquiv.toEquiv.{u2, u1} M N _inst_1 _inst_2 f)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 f))
 Case conversion may be inaccurate. Consider using '#align mul_equiv.inv_fun_eq_symm MulEquiv.invFun_eq_symmₓ'. -/
 @[simp, to_additive]
 theorem invFun_eq_symm {f : M ≃* N} : f.invFun = f.symm :=
@@ -474,7 +474,7 @@ def trans (h1 : M ≃* N) (h2 : N ≃* P) : M ≃* P :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (y : N), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e) y)) y
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (y : N), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (a : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) a) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u2 u1, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u2 u1, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) y)) y
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (y : N), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (a : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) a) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) y)) y
 Case conversion may be inaccurate. Consider using '#align mul_equiv.apply_symm_apply MulEquiv.apply_symm_applyₓ'. -/
 /-- `e.symm` is a right inverse of `e`, written as `e (e.symm y) = y`. -/
 @[simp, to_additive "`e.symm` is a right inverse of `e`, written as `e (e.symm y) = y`."]
@@ -487,7 +487,7 @@ theorem apply_symm_apply (e : M ≃* N) (y : N) : e (e.symm y) = y :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (x : M), Eq.{succ u1} M (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e x)) x
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (a : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e x)) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u2 u1, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e x)) x
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (a : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e x)) x
 Case conversion may be inaccurate. Consider using '#align mul_equiv.symm_apply_apply MulEquiv.symm_apply_applyₓ'. -/
 /-- `e.symm` is a left inverse of `e`, written as `e.symm (e y) = y`. -/
 @[simp, to_additive "`e.symm` is a left inverse of `e`, written as `e.symm (e y) = y`."]
@@ -500,7 +500,7 @@ theorem symm_apply_apply (e : M ≃* N) (x : M) : e.symm (e x) = x :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2), Eq.{succ u1} (M -> M) (Function.comp.{succ u1, succ u2, succ u1} M N M (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e)) (id.{succ u1} M)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{succ u2} (M -> M) (Function.comp.{succ u2, succ u1, succ u2} M N M (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u2 u1, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e)) (id.{succ u2} M)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{succ u2} (M -> M) (Function.comp.{succ u2, succ u1, succ u2} M N M (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e)) (id.{succ u2} M)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.symm_comp_self MulEquiv.symm_comp_selfₓ'. -/
 @[simp, to_additive]
 theorem symm_comp_self (e : M ≃* N) : e.symm ∘ e = id :=
@@ -512,7 +512,7 @@ theorem symm_comp_self (e : M ≃* N) : e.symm ∘ e = id :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2), Eq.{succ u2} (N -> N) (Function.comp.{succ u2, succ u1, succ u2} N M N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e) (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e))) (id.{succ u2} N)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{succ u1} (N -> N) (Function.comp.{succ u1, succ u2, succ u1} N M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u2 u1, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e))) (id.{succ u1} N)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{succ u1} (N -> N) (Function.comp.{succ u1, succ u2, succ u1} N M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e))) (id.{succ u1} N)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.self_comp_symm MulEquiv.self_comp_symmₓ'. -/
 @[simp, to_additive]
 theorem self_comp_symm (e : M ≃* N) : e ∘ e.symm = id :=
@@ -572,7 +572,7 @@ theorem trans_apply (e₁ : M ≃* N) (e₂ : N ≃* P) (m : M) : e₁.trans e
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} {P : Type.{u3}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] [_inst_3 : Mul.{u3} P] (e₁ : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (e₂ : MulEquiv.{u2, u3} N P _inst_2 _inst_3) (p : P), Eq.{succ u1} M (coeFn.{max (succ u3) (succ u1), max (succ u3) (succ u1)} (MulEquiv.{u3, u1} P M _inst_3 _inst_1) (fun (_x : MulEquiv.{u3, u1} P M _inst_3 _inst_1) => P -> M) (MulEquiv.hasCoeToFun.{u3, u1} P M _inst_3 _inst_1) (MulEquiv.symm.{u1, u3} M P _inst_1 _inst_3 (MulEquiv.trans.{u1, u2, u3} M N P _inst_1 _inst_2 _inst_3 e₁ e₂)) p) (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e₁) (coeFn.{max (succ u3) (succ u2), max (succ u3) (succ u2)} (MulEquiv.{u3, u2} P N _inst_3 _inst_2) (fun (_x : MulEquiv.{u3, u2} P N _inst_3 _inst_2) => P -> N) (MulEquiv.hasCoeToFun.{u3, u2} P N _inst_3 _inst_2) (MulEquiv.symm.{u2, u3} N P _inst_2 _inst_3 e₂) p))
 but is expected to have type
-  forall {M : Type.{u3}} {N : Type.{u2}} {P : Type.{u1}} [_inst_1 : Mul.{u3} M] [_inst_2 : Mul.{u2} N] [_inst_3 : Mul.{u1} P] (e₁ : MulEquiv.{u3, u2} M N _inst_1 _inst_2) (e₂ : MulEquiv.{u2, u1} N P _inst_2 _inst_3) (p : P), Eq.{succ u3} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : P) => M) p) (FunLike.coe.{max (succ u3) (succ u1), succ u1, succ u3} (MulEquiv.{u1, u3} P M _inst_3 _inst_1) P (fun (_x : P) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : P) => M) _x) (EmbeddingLike.toFunLike.{max (succ u3) (succ u1), succ u1, succ u3} (MulEquiv.{u1, u3} P M _inst_3 _inst_1) P M (EquivLike.toEmbeddingLike.{max (succ u3) (succ u1), succ u1, succ u3} (MulEquiv.{u1, u3} P M _inst_3 _inst_1) P M (MulEquivClass.toEquivLike.{max u3 u1, u1, u3} (MulEquiv.{u1, u3} P M _inst_3 _inst_1) P M _inst_3 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u3} P M _inst_3 _inst_1)))) (MulEquiv.symm.{u3, u1} M P _inst_1 _inst_3 (MulEquiv.trans.{u3, u2, u1} M N P _inst_1 _inst_2 _inst_3 e₁ e₂)) p) (FunLike.coe.{max (succ u3) (succ u2), succ u2, succ u3} (MulEquiv.{u2, u3} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u3) (succ u2), succ u2, succ u3} (MulEquiv.{u2, u3} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u3) (succ u2), succ u2, succ u3} (MulEquiv.{u2, u3} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u3 u2, u2, u3} (MulEquiv.{u2, u3} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u2, u3} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u3, u2} M N _inst_1 _inst_2 e₁) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} P N _inst_3 _inst_2) P (fun (_x : P) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : P) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} P N _inst_3 _inst_2) P N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} P N _inst_3 _inst_2) P N (MulEquivClass.toEquivLike.{max u2 u1, u1, u2} (MulEquiv.{u1, u2} P N _inst_3 _inst_2) P N _inst_3 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} P N _inst_3 _inst_2)))) (MulEquiv.symm.{u2, u1} N P _inst_2 _inst_3 e₂) p))
+  forall {M : Type.{u3}} {N : Type.{u2}} {P : Type.{u1}} [_inst_1 : Mul.{u3} M] [_inst_2 : Mul.{u2} N] [_inst_3 : Mul.{u1} P] (e₁ : MulEquiv.{u3, u2} M N _inst_1 _inst_2) (e₂ : MulEquiv.{u2, u1} N P _inst_2 _inst_3) (p : P), Eq.{succ u3} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : P) => M) p) (FunLike.coe.{max (succ u1) (succ u3), succ u1, succ u3} (MulEquiv.{u1, u3} P M _inst_3 _inst_1) P (fun (_x : P) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : P) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u3), succ u1, succ u3} (MulEquiv.{u1, u3} P M _inst_3 _inst_1) P M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u3), succ u1, succ u3} (MulEquiv.{u1, u3} P M _inst_3 _inst_1) P M (MulEquivClass.toEquivLike.{max u1 u3, u1, u3} (MulEquiv.{u1, u3} P M _inst_3 _inst_1) P M _inst_3 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u3} P M _inst_3 _inst_1)))) (MulEquiv.symm.{u3, u1} M P _inst_1 _inst_3 (MulEquiv.trans.{u3, u2, u1} M N P _inst_1 _inst_2 _inst_3 e₁ e₂)) p) (FunLike.coe.{max (succ u2) (succ u3), succ u2, succ u3} (MulEquiv.{u2, u3} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u3), succ u2, succ u3} (MulEquiv.{u2, u3} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u2) (succ u3), succ u2, succ u3} (MulEquiv.{u2, u3} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u2 u3, u2, u3} (MulEquiv.{u2, u3} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u2, u3} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u3, u2} M N _inst_1 _inst_2 e₁) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} P N _inst_3 _inst_2) P (fun (_x : P) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : P) => N) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} P N _inst_3 _inst_2) P N (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} P N _inst_3 _inst_2) P N (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} P N _inst_3 _inst_2) P N _inst_3 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} P N _inst_3 _inst_2)))) (MulEquiv.symm.{u2, u1} N P _inst_2 _inst_3 e₂) p))
 Case conversion may be inaccurate. Consider using '#align mul_equiv.symm_trans_apply MulEquiv.symm_trans_applyₓ'. -/
 @[simp, to_additive]
 theorem symm_trans_apply (e₁ : M ≃* N) (e₂ : N ≃* P) (p : P) :
@@ -597,7 +597,7 @@ theorem apply_eq_iff_eq (e : M ≃* N) {x y : M} : e x = e y ↔ x = y :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) {x : M} {y : N}, Iff (Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e x) y) (Eq.{succ u1} M x (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e) y))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) {x : M} {y : N}, Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e x) y) (Eq.{succ u2} M x (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u2 u1, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) y))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) {x : M} {y : N}, Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e x) y) (Eq.{succ u2} M x (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) y))
 Case conversion may be inaccurate. Consider using '#align mul_equiv.apply_eq_iff_symm_apply MulEquiv.apply_eq_iff_symm_applyₓ'. -/
 @[to_additive]
 theorem apply_eq_iff_symm_apply (e : M ≃* N) {x : M} {y : N} : e x = y ↔ x = e.symm y :=
@@ -609,7 +609,7 @@ theorem apply_eq_iff_symm_apply (e : M ≃* N) {x : M} {y : N} : e x = y ↔ x =
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) {x : N} {y : M}, Iff (Eq.{succ u1} M (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e) x) y) (Eq.{succ u2} N x (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e y))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) {x : N} {y : (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) x}, Iff (Eq.{succ u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) x) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u2 u1, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) x) y) (Eq.{succ u1} N x (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e y))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) {x : N} {y : (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) x}, Iff (Eq.{succ u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) x) y) (Eq.{succ u1} N x (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e y))
 Case conversion may be inaccurate. Consider using '#align mul_equiv.symm_apply_eq MulEquiv.symm_apply_eqₓ'. -/
 @[to_additive]
 theorem symm_apply_eq (e : M ≃* N) {x y} : e.symm x = y ↔ x = e y :=
@@ -621,7 +621,7 @@ theorem symm_apply_eq (e : M ≃* N) {x y} : e.symm x = y ↔ x = e y :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) {x : N} {y : M}, Iff (Eq.{succ u1} M y (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e) x)) (Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e y) x)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) {x : N} {y : (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) x}, Iff (Eq.{succ u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) x) y (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u2 u1, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) x)) (Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) y) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e y) x)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) {x : N} {y : (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) x}, Iff (Eq.{succ u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) x) y (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e) x)) (Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) y) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e y) x)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.eq_symm_apply MulEquiv.eq_symm_applyₓ'. -/
 @[to_additive]
 theorem eq_symm_apply (e : M ≃* N) {x y} : y = e.symm x ↔ e y = x :=
@@ -633,7 +633,7 @@ theorem eq_symm_apply (e : M ≃* N) {x y} : y = e.symm x ↔ e y = x :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {α : Type.{u3}} (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (f : N -> α) (g : M -> α), Iff (Eq.{max (succ u2) (succ u3)} (N -> α) f (Function.comp.{succ u2, succ u1, succ u3} N M α g (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e)))) (Eq.{max (succ u1) (succ u3)} (M -> α) (Function.comp.{succ u1, succ u2, succ u3} M N α f (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e)) g)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {α : Type.{u3}} (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (f : N -> α) (g : M -> α), Iff (Eq.{max (succ u1) (succ u3)} (N -> α) f (Function.comp.{succ u1, succ u2, succ u3} N M α g (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u2 u1, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e)))) (Eq.{max (succ u2) (succ u3)} (M -> α) (Function.comp.{succ u2, succ u1, succ u3} M N α f (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e)) g)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {α : Type.{u3}} (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (f : N -> α) (g : M -> α), Iff (Eq.{max (succ u1) (succ u3)} (N -> α) f (Function.comp.{succ u1, succ u2, succ u3} N M α g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e)))) (Eq.{max (succ u2) (succ u3)} (M -> α) (Function.comp.{succ u2, succ u1, succ u3} M N α f (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e)) g)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.eq_comp_symm MulEquiv.eq_comp_symmₓ'. -/
 @[to_additive]
 theorem eq_comp_symm {α : Type _} (e : M ≃* N) (f : N → α) (g : M → α) :
@@ -646,7 +646,7 @@ theorem eq_comp_symm {α : Type _} (e : M ≃* N) (f : N → α) (g : M → α)
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {α : Type.{u3}} (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (f : N -> α) (g : M -> α), Iff (Eq.{max (succ u2) (succ u3)} (N -> α) (Function.comp.{succ u2, succ u1, succ u3} N M α g (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e))) f) (Eq.{max (succ u1) (succ u3)} (M -> α) g (Function.comp.{succ u1, succ u2, succ u3} M N α f (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e)))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {α : Type.{u3}} (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (f : N -> α) (g : M -> α), Iff (Eq.{max (succ u1) (succ u3)} (N -> α) (Function.comp.{succ u1, succ u2, succ u3} N M α g (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u2 u1, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e))) f) (Eq.{max (succ u2) (succ u3)} (M -> α) g (Function.comp.{succ u2, succ u1, succ u3} M N α f (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e)))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {α : Type.{u3}} (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (f : N -> α) (g : M -> α), Iff (Eq.{max (succ u1) (succ u3)} (N -> α) (Function.comp.{succ u1, succ u2, succ u3} N M α g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e))) f) (Eq.{max (succ u2) (succ u3)} (M -> α) g (Function.comp.{succ u2, succ u1, succ u3} M N α f (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e)))
 Case conversion may be inaccurate. Consider using '#align mul_equiv.comp_symm_eq MulEquiv.comp_symm_eqₓ'. -/
 @[to_additive]
 theorem comp_symm_eq {α : Type _} (e : M ≃* N) (f : N → α) (g : M → α) :
@@ -659,7 +659,7 @@ theorem comp_symm_eq {α : Type _} (e : M ≃* N) (f : N → α) (g : M → α)
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {α : Type.{u3}} (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (f : α -> M) (g : α -> N), Iff (Eq.{max (succ u3) (succ u1)} (α -> M) f (Function.comp.{succ u3, succ u2, succ u1} α N M (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e)) g)) (Eq.{max (succ u3) (succ u2)} (α -> N) (Function.comp.{succ u3, succ u1, succ u2} α M N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e) f) g)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {α : Type.{u3}} (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (f : α -> M) (g : α -> N), Iff (Eq.{max (succ u2) (succ u3)} (α -> M) f (Function.comp.{succ u3, succ u1, succ u2} α N M (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u2 u1, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e)) g)) (Eq.{max (succ u1) (succ u3)} (α -> N) (Function.comp.{succ u3, succ u2, succ u1} α M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) f) g)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {α : Type.{u3}} (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (f : α -> M) (g : α -> N), Iff (Eq.{max (succ u2) (succ u3)} (α -> M) f (Function.comp.{succ u3, succ u1, succ u2} α N M (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e)) g)) (Eq.{max (succ u1) (succ u3)} (α -> N) (Function.comp.{succ u3, succ u2, succ u1} α M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) f) g)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.eq_symm_comp MulEquiv.eq_symm_compₓ'. -/
 @[to_additive]
 theorem eq_symm_comp {α : Type _} (e : M ≃* N) (f : α → M) (g : α → N) :
@@ -672,7 +672,7 @@ theorem eq_symm_comp {α : Type _} (e : M ≃* N) (f : α → M) (g : α → N)
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {α : Type.{u3}} (e : MulEquiv.{u1, u2} M N _inst_1 _inst_2) (f : α -> M) (g : α -> N), Iff (Eq.{max (succ u3) (succ u1)} (α -> M) (Function.comp.{succ u3, succ u2, succ u1} α N M (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulEquiv.{u2, u1} N M _inst_2 _inst_1) (fun (_x : MulEquiv.{u2, u1} N M _inst_2 _inst_1) => N -> M) (MulEquiv.hasCoeToFun.{u2, u1} N M _inst_2 _inst_1) (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 e)) g) f) (Eq.{max (succ u3) (succ u2)} (α -> N) g (Function.comp.{succ u3, succ u1, succ u2} α M N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) e) f))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {α : Type.{u3}} (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (f : α -> M) (g : α -> N), Iff (Eq.{max (succ u2) (succ u3)} (α -> M) (Function.comp.{succ u3, succ u1, succ u2} α N M (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u2 u1, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e)) g) f) (Eq.{max (succ u1) (succ u3)} (α -> N) g (Function.comp.{succ u3, succ u2, succ u1} α M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) f))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {α : Type.{u3}} (e : MulEquiv.{u2, u1} M N _inst_1 _inst_2) (f : α -> M) (g : α -> N), Iff (Eq.{max (succ u2) (succ u3)} (α -> M) (Function.comp.{succ u3, succ u1, succ u2} α N M (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N (fun (_x : N) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : N) => M) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (EquivLike.toEmbeddingLike.{max (succ u1) (succ u2), succ u1, succ u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)))) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 e)) g) f) (Eq.{max (succ u1) (succ u3)} (α -> N) g (Function.comp.{succ u3, succ u2, succ u1} α M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) e) f))
 Case conversion may be inaccurate. Consider using '#align mul_equiv.symm_comp_eq MulEquiv.symm_comp_eqₓ'. -/
 @[to_additive]
 theorem symm_comp_eq {α : Type _} (e : M ≃* N) (f : α → M) (g : α → N) :

bump to nightly-2023-04-14-00

mathlib commit https://github.com/leanprover-community/mathlib/commit/347636a7a80595d55bedf6e6fbd996a3c39da69a

48c54fa4

Diff

@@ -155,7 +155,7 @@ instance (priority := 100) [MulOneClass M] [MulOneClass N] [MulEquivClass F M N]
 lean 3 declaration is
   forall (F : Type.{u1}) {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : MulZeroOneClass.{u2} α] [_inst_2 : MulZeroOneClass.{u3} β] [_inst_3 : MulEquivClass.{u1, u2, u3} F α β (MulZeroClass.toHasMul.{u2} α (MulZeroOneClass.toMulZeroClass.{u2} α _inst_1)) (MulZeroClass.toHasMul.{u3} β (MulZeroOneClass.toMulZeroClass.{u3} β _inst_2))], MonoidWithZeroHomClass.{u1, u2, u3} F α β _inst_1 _inst_2
 but is expected to have type
-  forall (F : Type.{u1}) {α : Type.{u2}} {β : Type.{u3}} {_inst_1 : MulZeroOneClass.{u2} α} {_inst_2 : MulZeroOneClass.{u3} β} [_inst_3 : MulEquivClass.{u1, u2, u3} F α β (MulZeroClass.toMul.{u2} α (MulZeroOneClass.toMulZeroClass.{u2} α _inst_1)) (MulZeroClass.toMul.{u3} β (MulZeroOneClass.toMulZeroClass.{u3} β _inst_2))], MonoidWithZeroHomClass.{u1, u2, u3} F α β _inst_1 _inst_2
+  forall (F : Type.{u1}) {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : MulZeroOneClass.{u2} α] [_inst_2 : MulZeroOneClass.{u3} β] [_inst_3 : MulEquivClass.{u1, u2, u3} F α β (MulZeroClass.toMul.{u2} α (MulZeroOneClass.toMulZeroClass.{u2} α _inst_1)) (MulZeroClass.toMul.{u3} β (MulZeroOneClass.toMulZeroClass.{u3} β _inst_2))], MonoidWithZeroHomClass.{u1, u2, u3} F α β _inst_1 _inst_2
 Case conversion may be inaccurate. Consider using '#align mul_equiv_class.to_monoid_with_zero_hom_class MulEquivClass.toMonoidWithZeroHomClassₓ'. -/
 -- See note [lower instance priority]
 instance (priority := 100) toMonoidWithZeroHomClass {α β : Type _} [MulZeroOneClass α]

bump to nightly-2023-03-23-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/57e09a1296bfb4330ddf6624f1028ba186117d82

372772ba

Diff

@@ -230,17 +230,17 @@ instance [Mul M] [Mul N] : MulEquivClass (M ≃* N) M N
 
 variable [Mul M] [Mul N] [Mul P] [Mul Q]
 
-/- warning: mul_equiv.to_equiv_eq_coe clashes with [anonymous] -> [anonymous]
-warning: mul_equiv.to_equiv_eq_coe -> [anonymous] is a dubious translation:
+/- warning: mul_equiv.to_equiv_eq_coe -> MulEquiv.toEquiv_eq_coe is a dubious translation:
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (f : MulEquiv.{u1, u2} M N _inst_1 _inst_2), Eq.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{succ u1, succ u2} M N) (MulEquiv.toEquiv.{u1, u2} M N _inst_1 _inst_2 f) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)}) [self : HasLiftT.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} a b] => self.0) (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (HasLiftT.mk.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (CoeTCₓ.coe.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (Equiv.hasCoeT.{succ u1, succ u2, max (succ u1) (succ u2)} M N (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.mulEquivClass.{u1, u2} M N _inst_1 _inst_2))))) f)
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}}, (Nat -> M -> N) -> Nat -> (List.{u1} M) -> (List.{u2} N)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.to_equiv_eq_coe [anonymous]ₓ'. -/
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (f : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{max (succ u2) (succ u1)} (Equiv.{succ u2, succ u1} M N) (MulEquiv.toEquiv.{u2, u1} M N _inst_1 _inst_2 f) (EquivLike.toEquiv.{succ u2, succ u1, max (succ u2) (succ u1)} M N (MulEquiv.{u2, u1} M N _inst_1 _inst_2) (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)) f)
+Case conversion may be inaccurate. Consider using '#align mul_equiv.to_equiv_eq_coe MulEquiv.toEquiv_eq_coeₓ'. -/
 @[simp, to_additive]
-theorem [anonymous] (f : M ≃* N) : f.toEquiv = f :=
+theorem toEquiv_eq_coe (f : M ≃* N) : f.toEquiv = f :=
   rfl
-#align mul_equiv.to_equiv_eq_coe [anonymous]
+#align mul_equiv.to_equiv_eq_coe MulEquiv.toEquiv_eq_coe
+#align add_equiv.to_equiv_eq_coe AddEquiv.toEquiv_eq_coe
 
 /- warning: mul_equiv.to_fun_eq_coe clashes with [anonymous] -> [anonymous]
 warning: mul_equiv.to_fun_eq_coe -> [anonymous] is a dubious translation:
@@ -258,7 +258,7 @@ theorem [anonymous] {f : M ≃* N} : f.toFun = f :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {f : MulEquiv.{u1, u2} M N _inst_1 _inst_2}, Eq.{max (succ u1) (succ u2)} (M -> N) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} M N) (fun (_x : Equiv.{succ u1, succ u2} M N) => M -> N) (Equiv.hasCoeToFun.{succ u1, succ u2} M N) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)}) [self : HasLiftT.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} a b] => self.0) (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (HasLiftT.mk.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (CoeTCₓ.coe.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (Equiv.hasCoeT.{succ u1, succ u2, max (succ u1) (succ u2)} M N (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.mulEquivClass.{u1, u2} M N _inst_1 _inst_2))))) f)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (f : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} M N) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => N) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} M N) (MulEquiv.toEquiv.{u2, u1} M N _inst_1 _inst_2 f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (f : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} M N) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => N) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} M N) (EquivLike.toEquiv.{succ u2, succ u1, max (succ u2) (succ u1)} M N (MulEquiv.{u2, u1} M N _inst_1 _inst_2) (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)) f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.coe_to_equiv MulEquiv.coe_toEquivₓ'. -/
 @[simp, to_additive]
 theorem coe_toEquiv {f : M ≃* N} : ⇑(f : M ≃ N) = f :=
@@ -390,7 +390,7 @@ initialize_simps_projections MulEquiv (toFun → apply, invFun → symm_apply)
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] (f : MulEquiv.{u1, u2} M N _inst_1 _inst_2), Eq.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2)} (Equiv.{succ u2, succ u1} N M) (MulEquiv.toEquiv.{u2, u1} N M _inst_2 _inst_1 (MulEquiv.symm.{u1, u2} M N _inst_1 _inst_2 f)) (Equiv.symm.{succ u1, succ u2} M N (MulEquiv.toEquiv.{u1, u2} M N _inst_1 _inst_2 f))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (f : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{max (succ u2) (succ u1)} (Equiv.{succ u1, succ u2} N M) (MulEquiv.toEquiv.{u1, u2} N M _inst_2 _inst_1 (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 f)) (Equiv.symm.{succ u2, succ u1} M N (MulEquiv.toEquiv.{u2, u1} M N _inst_1 _inst_2 f))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (f : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{max (succ u2) (succ u1)} (Equiv.{succ u1, succ u2} N M) (EquivLike.toEquiv.{succ u1, succ u2, max (succ u2) (succ u1)} N M (MulEquiv.{u1, u2} N M _inst_2 _inst_1) (MulEquivClass.toEquivLike.{max u2 u1, u1, u2} (MulEquiv.{u1, u2} N M _inst_2 _inst_1) N M _inst_2 _inst_1 (MulEquiv.instMulEquivClassMulEquiv.{u1, u2} N M _inst_2 _inst_1)) (MulEquiv.symm.{u2, u1} M N _inst_1 _inst_2 f)) (Equiv.symm.{succ u2, succ u1} M N (EquivLike.toEquiv.{succ u2, succ u1, max (succ u2) (succ u1)} M N (MulEquiv.{u2, u1} M N _inst_1 _inst_2) (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)) f))
 Case conversion may be inaccurate. Consider using '#align mul_equiv.to_equiv_symm MulEquiv.toEquiv_symmₓ'. -/
 @[simp, to_additive]
 theorem toEquiv_symm (f : M ≃* N) : f.symm.toEquiv = f.toEquiv.symm :=

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -64,7 +64,7 @@ def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M) (h₁ : Funct
 lean 3 declaration is
   forall {A : Type.{u1}} {B : Type.{u2}} [_inst_1 : Monoid.{u1} A] [_inst_2 : Monoid.{u2} B] (f : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (g : B -> A), (Function.LeftInverse.{succ u1, succ u2} A B g (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (fun (_x : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) => A -> B) (MonoidHom.hasCoeToFun.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) f)) -> (Function.RightInverse.{succ u1, succ u2} A B g (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (fun (_x : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) => A -> B) (MonoidHom.hasCoeToFun.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) f)) -> (MonoidHom.{u2, u1} B A (Monoid.toMulOneClass.{u2} B _inst_2) (Monoid.toMulOneClass.{u1} A _inst_1))
 but is expected to have type
-  forall {A : Type.{u1}} {B : Type.{u2}} [_inst_1 : Monoid.{u1} A] [_inst_2 : Monoid.{u2} B] (f : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (g : B -> A), (Function.LeftInverse.{succ u1, succ u2} A B g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : A) => B) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (MulOneClass.toMul.{u1} A (Monoid.toMulOneClass.{u1} A _inst_1)) (MulOneClass.toMul.{u2} B (Monoid.toMulOneClass.{u2} B _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2) (MonoidHom.monoidHomClass.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)))) f)) -> (Function.RightInverse.{succ u1, succ u2} A B g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : A) => B) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (MulOneClass.toMul.{u1} A (Monoid.toMulOneClass.{u1} A _inst_1)) (MulOneClass.toMul.{u2} B (Monoid.toMulOneClass.{u2} B _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2) (MonoidHom.monoidHomClass.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)))) f)) -> (MonoidHom.{u2, u1} B A (Monoid.toMulOneClass.{u2} B _inst_2) (Monoid.toMulOneClass.{u1} A _inst_1))
+  forall {A : Type.{u1}} {B : Type.{u2}} [_inst_1 : Monoid.{u1} A] [_inst_2 : Monoid.{u2} B] (f : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (g : B -> A), (Function.LeftInverse.{succ u1, succ u2} A B g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : A) => B) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (MulOneClass.toMul.{u1} A (Monoid.toMulOneClass.{u1} A _inst_1)) (MulOneClass.toMul.{u2} B (Monoid.toMulOneClass.{u2} B _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2) (MonoidHom.monoidHomClass.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)))) f)) -> (Function.RightInverse.{succ u1, succ u2} A B g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : A) => B) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (MulOneClass.toMul.{u1} A (Monoid.toMulOneClass.{u1} A _inst_1)) (MulOneClass.toMul.{u2} B (Monoid.toMulOneClass.{u2} B _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2) (MonoidHom.monoidHomClass.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)))) f)) -> (MonoidHom.{u2, u1} B A (Monoid.toMulOneClass.{u2} B _inst_2) (Monoid.toMulOneClass.{u1} A _inst_1))
 Case conversion may be inaccurate. Consider using '#align monoid_hom.inverse MonoidHom.inverseₓ'. -/
 /-- The inverse of a bijective `monoid_hom` is a `monoid_hom`. -/
 @[to_additive "The inverse of a bijective `add_monoid_hom` is an `add_monoid_hom`.", simps]
@@ -258,7 +258,7 @@ theorem [anonymous] {f : M ≃* N} : f.toFun = f :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {f : MulEquiv.{u1, u2} M N _inst_1 _inst_2}, Eq.{max (succ u1) (succ u2)} (M -> N) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} M N) (fun (_x : Equiv.{succ u1, succ u2} M N) => M -> N) (Equiv.hasCoeToFun.{succ u1, succ u2} M N) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)}) [self : HasLiftT.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} a b] => self.0) (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (HasLiftT.mk.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (CoeTCₓ.coe.{max (succ u1) (succ u2), max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (Equiv.{succ u1, succ u2} M N) (Equiv.hasCoeT.{succ u1, succ u2, max (succ u1) (succ u2)} M N (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (MulEquivClass.toEquivLike.{max u1 u2, u1, u2} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.mulEquivClass.{u1, u2} M N _inst_1 _inst_2))))) f)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (f : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} M N) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : M) => N) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} M N) (MulEquiv.toEquiv.{u2, u1} M N _inst_1 _inst_2 f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] (f : MulEquiv.{u2, u1} M N _inst_1 _inst_2), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} M N) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => N) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} M N) (MulEquiv.toEquiv.{u2, u1} M N _inst_1 _inst_2 f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.coe_to_equiv MulEquiv.coe_toEquivₓ'. -/
 @[simp, to_additive]
 theorem coe_toEquiv {f : M ≃* N} : ⇑(f : M ≃ N) = f :=
@@ -270,7 +270,7 @@ theorem coe_toEquiv {f : M ≃* N} : ⇑(f : M ≃ N) = f :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {f : MulEquiv.{u1, u2} M N _inst_1 _inst_2}, Eq.{max (succ u1) (succ u2)} (M -> N) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulHom.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) (MulEquiv.toMulHom.{u1, u2} M N _inst_1 _inst_2 f)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {f : MulEquiv.{u2, u1} M N _inst_1 _inst_2}, Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulHom.mulHomClass.{u2, u1} M N _inst_1 _inst_2)) (MulEquiv.toMulHom.{u2, u1} M N _inst_1 _inst_2 f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {f : MulEquiv.{u2, u1} M N _inst_1 _inst_2}, Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulHom.mulHomClass.{u2, u1} M N _inst_1 _inst_2)) (MulEquiv.toMulHom.{u2, u1} M N _inst_1 _inst_2 f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.coe_to_mul_hom MulEquiv.coe_toMulHomₓ'. -/
 @[simp, to_additive]
 theorem coe_toMulHom {f : M ≃* N} : ⇑f.toMulHom = f :=
@@ -882,7 +882,7 @@ noncomputable def ofBijective {M N F} [Mul M] [Mul N] [MulHomClass F M N] (f : F
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N] {n : N} (f : MonoidHom.{u1, u2} M N _inst_5 _inst_6) (hf : Function.Bijective.{succ u1, succ u2} M N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (fun (_x : MonoidHom.{u1, u2} M N _inst_5 _inst_6) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N _inst_5 _inst_6) f)), Eq.{succ u2} N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (fun (_x : MonoidHom.{u1, u2} M N _inst_5 _inst_6) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N _inst_5 _inst_6) f (coeFn.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2), max (succ u2) (succ u1)} (Equiv.{succ u2, succ u1} N M) (fun (_x : Equiv.{succ u2, succ u1} N M) => N -> M) (Equiv.hasCoeToFun.{succ u2, succ u1} N M) (Equiv.symm.{succ u1, succ u2} M N (Equiv.ofBijective.{succ u1, succ u2} M N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (fun (_x : MonoidHom.{u1, u2} M N _inst_5 _inst_6) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N _inst_5 _inst_6) f) hf)) n)) n
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] {n : N} (f : MonoidHom.{u2, u1} M N _inst_5 _inst_6) (hf : Function.Bijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f)), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} N M) N (fun (a : N) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : N) => M) a) (Equiv.instFunLikeEquiv.{succ u1, succ u2} N M) (Equiv.symm.{succ u2, succ u1} M N (Equiv.ofBijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (a : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f) hf)) n)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} N M) N (fun (_x : N) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : N) => M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} N M) (Equiv.symm.{succ u2, succ u1} M N (Equiv.ofBijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f) hf)) n)) n
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] {n : N} (f : MonoidHom.{u2, u1} M N _inst_5 _inst_6) (hf : Function.Bijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f)), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} N M) N (fun (a : N) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : N) => M) a) (Equiv.instFunLikeEquiv.{succ u1, succ u2} N M) (Equiv.symm.{succ u2, succ u1} M N (Equiv.ofBijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (a : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f) hf)) n)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} N M) N (fun (_x : N) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : N) => M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} N M) (Equiv.symm.{succ u2, succ u1} M N (Equiv.ofBijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f) hf)) n)) n
 Case conversion may be inaccurate. Consider using '#align mul_equiv.of_bijective_apply_symm_apply MulEquiv.ofBijective_apply_symm_applyₓ'. -/
 @[simp]
 theorem ofBijective_apply_symm_apply {M N} [MulOneClass M] [MulOneClass N] {n : N} (f : M →* N)
@@ -910,7 +910,7 @@ def toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) : M →* N
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N] (e : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)), Eq.{max (succ u1) (succ u2)} (M -> N) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (fun (_x : MonoidHom.{u1, u2} M N _inst_5 _inst_6) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N _inst_5 _inst_6) (MulEquiv.toMonoidHom.{u1, u2} M N _inst_5 _inst_6 e)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) (fun (_x : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) e)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] (e : MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) (MulEquiv.toMonoidHom.{u2, u1} M N _inst_5 _inst_6 e)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6))))) e)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] (e : MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) (MulEquiv.toMonoidHom.{u2, u1} M N _inst_5 _inst_6 e)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6))))) e)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.coe_to_monoid_hom MulEquiv.coe_toMonoidHomₓ'. -/
 @[simp, to_additive]
 theorem coe_toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (e : M ≃* N) : ⇑e.toMonoidHom = e :=

bump to nightly-2023-03-11-16

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

cd44fb92

Diff

@@ -163,9 +163,9 @@ instance (priority := 100) toMonoidWithZeroHomClass {α β : Type _} [MulZeroOne
   { MulEquivClass.monoidHomClass _ with
     map_zero := fun e =>
       calc
-        e 0 = e 0 * e (EquivLike.inv e 0) := by rw [← map_mul, zero_mul]
+        e 0 = e 0 * e (EquivLike.inv e 0) := by rw [← map_mul, MulZeroClass.zero_mul]
         _ = 0 := by
-          convert mul_zero _
+          convert MulZeroClass.mul_zero _
           exact EquivLike.right_inv e _
          }
 #align mul_equiv_class.to_monoid_with_zero_hom_class MulEquivClass.toMonoidWithZeroHomClass

bump to nightly-2023-03-08-18

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

10f15343

Diff

@@ -64,7 +64,7 @@ def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M) (h₁ : Funct
 lean 3 declaration is
   forall {A : Type.{u1}} {B : Type.{u2}} [_inst_1 : Monoid.{u1} A] [_inst_2 : Monoid.{u2} B] (f : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (g : B -> A), (Function.LeftInverse.{succ u1, succ u2} A B g (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (fun (_x : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) => A -> B) (MonoidHom.hasCoeToFun.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) f)) -> (Function.RightInverse.{succ u1, succ u2} A B g (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (fun (_x : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) => A -> B) (MonoidHom.hasCoeToFun.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) f)) -> (MonoidHom.{u2, u1} B A (Monoid.toMulOneClass.{u2} B _inst_2) (Monoid.toMulOneClass.{u1} A _inst_1))
 but is expected to have type
-  forall {A : Type.{u1}} {B : Type.{u2}} [_inst_1 : Monoid.{u1} A] [_inst_2 : Monoid.{u2} B] (f : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (g : B -> A), (Function.LeftInverse.{succ u1, succ u2} A B g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : A) => B) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (MulOneClass.toMul.{u1} A (Monoid.toMulOneClass.{u1} A _inst_1)) (MulOneClass.toMul.{u2} B (Monoid.toMulOneClass.{u2} B _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2) (MonoidHom.monoidHomClass.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)))) f)) -> (Function.RightInverse.{succ u1, succ u2} A B g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : A) => B) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (MulOneClass.toMul.{u1} A (Monoid.toMulOneClass.{u1} A _inst_1)) (MulOneClass.toMul.{u2} B (Monoid.toMulOneClass.{u2} B _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2) (MonoidHom.monoidHomClass.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)))) f)) -> (MonoidHom.{u2, u1} B A (Monoid.toMulOneClass.{u2} B _inst_2) (Monoid.toMulOneClass.{u1} A _inst_1))
+  forall {A : Type.{u1}} {B : Type.{u2}} [_inst_1 : Monoid.{u1} A] [_inst_2 : Monoid.{u2} B] (f : MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) (g : B -> A), (Function.LeftInverse.{succ u1, succ u2} A B g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : A) => B) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (MulOneClass.toMul.{u1} A (Monoid.toMulOneClass.{u1} A _inst_1)) (MulOneClass.toMul.{u2} B (Monoid.toMulOneClass.{u2} B _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2) (MonoidHom.monoidHomClass.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)))) f)) -> (Function.RightInverse.{succ u1, succ u2} A B g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : A) => B) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (MulOneClass.toMul.{u1} A (Monoid.toMulOneClass.{u1} A _inst_1)) (MulOneClass.toMul.{u2} B (Monoid.toMulOneClass.{u2} B _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)) A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2) (MonoidHom.monoidHomClass.{u1, u2} A B (Monoid.toMulOneClass.{u1} A _inst_1) (Monoid.toMulOneClass.{u2} B _inst_2)))) f)) -> (MonoidHom.{u2, u1} B A (Monoid.toMulOneClass.{u2} B _inst_2) (Monoid.toMulOneClass.{u1} A _inst_1))
 Case conversion may be inaccurate. Consider using '#align monoid_hom.inverse MonoidHom.inverseₓ'. -/
 /-- The inverse of a bijective `monoid_hom` is a `monoid_hom`. -/
 @[to_additive "The inverse of a bijective `add_monoid_hom` is an `add_monoid_hom`.", simps]
@@ -270,7 +270,7 @@ theorem coe_toEquiv {f : M ≃* N} : ⇑(f : M ≃ N) = f :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Mul.{u1} M] [_inst_2 : Mul.{u2} N] {f : MulEquiv.{u1, u2} M N _inst_1 _inst_2}, Eq.{max (succ u1) (succ u2)} (M -> N) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulHom.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) (MulEquiv.toMulHom.{u1, u2} M N _inst_1 _inst_2 f)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N _inst_1 _inst_2) (fun (_x : MulEquiv.{u1, u2} M N _inst_1 _inst_2) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N _inst_1 _inst_2) f)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {f : MulEquiv.{u2, u1} M N _inst_1 _inst_2}, Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulHom.mulHomClass.{u2, u1} M N _inst_1 _inst_2)) (MulEquiv.toMulHom.{u2, u1} M N _inst_1 _inst_2 f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Mul.{u2} M] [_inst_2 : Mul.{u1} N] {f : MulEquiv.{u2, u1} M N _inst_1 _inst_2}, Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulHom.mulHomClass.{u2, u1} M N _inst_1 _inst_2)) (MulEquiv.toMulHom.{u2, u1} M N _inst_1 _inst_2 f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N _inst_1 _inst_2) M N _inst_1 _inst_2 (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N _inst_1 _inst_2)))) f)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.coe_to_mul_hom MulEquiv.coe_toMulHomₓ'. -/
 @[simp, to_additive]
 theorem coe_toMulHom {f : M ≃* N} : ⇑f.toMulHom = f :=
@@ -882,7 +882,7 @@ noncomputable def ofBijective {M N F} [Mul M] [Mul N] [MulHomClass F M N] (f : F
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N] {n : N} (f : MonoidHom.{u1, u2} M N _inst_5 _inst_6) (hf : Function.Bijective.{succ u1, succ u2} M N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (fun (_x : MonoidHom.{u1, u2} M N _inst_5 _inst_6) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N _inst_5 _inst_6) f)), Eq.{succ u2} N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (fun (_x : MonoidHom.{u1, u2} M N _inst_5 _inst_6) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N _inst_5 _inst_6) f (coeFn.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2), max (succ u2) (succ u1)} (Equiv.{succ u2, succ u1} N M) (fun (_x : Equiv.{succ u2, succ u1} N M) => N -> M) (Equiv.hasCoeToFun.{succ u2, succ u1} N M) (Equiv.symm.{succ u1, succ u2} M N (Equiv.ofBijective.{succ u1, succ u2} M N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (fun (_x : MonoidHom.{u1, u2} M N _inst_5 _inst_6) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N _inst_5 _inst_6) f) hf)) n)) n
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] {n : N} (f : MonoidHom.{u2, u1} M N _inst_5 _inst_6) (hf : Function.Bijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f)), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} N M) N (fun (a : N) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : N) => M) a) (Equiv.instFunLikeEquiv.{succ u1, succ u2} N M) (Equiv.symm.{succ u2, succ u1} M N (Equiv.ofBijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (a : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f) hf)) n)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} N M) N (fun (_x : N) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : N) => M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} N M) (Equiv.symm.{succ u2, succ u1} M N (Equiv.ofBijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f) hf)) n)) n
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] {n : N} (f : MonoidHom.{u2, u1} M N _inst_5 _inst_6) (hf : Function.Bijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f)), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} N M) N (fun (a : N) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : N) => M) a) (Equiv.instFunLikeEquiv.{succ u1, succ u2} N M) (Equiv.symm.{succ u2, succ u1} M N (Equiv.ofBijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (a : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f) hf)) n)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} N M) N (fun (_x : N) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : N) => M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} N M) (Equiv.symm.{succ u2, succ u1} M N (Equiv.ofBijective.{succ u2, succ u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) f) hf)) n)) n
 Case conversion may be inaccurate. Consider using '#align mul_equiv.of_bijective_apply_symm_apply MulEquiv.ofBijective_apply_symm_applyₓ'. -/
 @[simp]
 theorem ofBijective_apply_symm_apply {M N} [MulOneClass M] [MulOneClass N] {n : N} (f : M →* N)
@@ -910,7 +910,7 @@ def toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) : M →* N
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_5 : MulOneClass.{u1} M] [_inst_6 : MulOneClass.{u2} N] (e : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)), Eq.{max (succ u1) (succ u2)} (M -> N) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N _inst_5 _inst_6) (fun (_x : MonoidHom.{u1, u2} M N _inst_5 _inst_6) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N _inst_5 _inst_6) (MulEquiv.toMonoidHom.{u1, u2} M N _inst_5 _inst_6 e)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) (fun (_x : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N (MulOneClass.toHasMul.{u1} M _inst_5) (MulOneClass.toHasMul.{u2} N _inst_6)) e)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] (e : MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) (MulEquiv.toMonoidHom.{u2, u1} M N _inst_5 _inst_6 e)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6))))) e)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_5 : MulOneClass.{u2} M] [_inst_6 : MulOneClass.{u1} N] (e : MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N _inst_5 _inst_6) M N _inst_5 _inst_6 (MonoidHom.monoidHomClass.{u2, u1} M N _inst_5 _inst_6))) (MulEquiv.toMonoidHom.{u2, u1} M N _inst_5 _inst_6 e)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6)) M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M _inst_5) (MulOneClass.toMul.{u1} N _inst_6))))) e)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.coe_to_monoid_hom MulEquiv.coe_toMonoidHomₓ'. -/
 @[simp, to_additive]
 theorem coe_toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (e : M ≃* N) : ⇑e.toMonoidHom = e :=

bump to nightly-2023-03-01-20

mathlib commit https://github.com/leanprover-community/mathlib/commit/4c586d291f189eecb9d00581aeb3dd998ac34442

20cadee0

Diff

@@ -146,7 +146,7 @@ instance (priority := 100) [MulOneClass M] [MulOneClass N] [MulEquivClass F M N]
     map_one := fun e =>
       calc
         e 1 = e 1 * 1 := (mul_one _).symm
-        _ = e 1 * e (inv e (1 : N) : M) := congr_arg _ (right_inv e 1).symm
+        _ = e 1 * e (inv e (1 : N) : M) := (congr_arg _ (right_inv e 1).symm)
         _ = e (inv e (1 : N)) := by rw [← map_mul, one_mul]
         _ = 1 := right_inv e 1
          }
@@ -371,15 +371,15 @@ theorem invFun_eq_symm {f : M ≃* N} : f.invFun = f.symm :=
 #align mul_equiv.inv_fun_eq_symm MulEquiv.invFun_eq_symm
 #align add_equiv.neg_fun_eq_symm AddEquiv.invFun_eq_symm
 
-#print MulEquiv.Simps.symmApply /-
+#print MulEquiv.Simps.symm_apply /-
 -- we don't hyperlink the note in the additive version, since that breaks syntax highlighting
 -- in the whole file.
 /-- See Note [custom simps projection] -/
 @[to_additive "See Note custom simps projection"]
-def Simps.symmApply (e : M ≃* N) : N → M :=
+def Simps.symm_apply (e : M ≃* N) : N → M :=
   e.symm
-#align mul_equiv.simps.symm_apply MulEquiv.Simps.symmApply
-#align add_equiv.simps.symm_apply AddEquiv.Simps.symmApply
+#align mul_equiv.simps.symm_apply MulEquiv.Simps.symm_apply
+#align add_equiv.simps.symm_apply AddEquiv.Simps.symm_apply
 -/
 
 initialize_simps_projections AddEquiv (toFun → apply, invFun → symm_apply)

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

chore(*): remove empty lines between variable statements (#11418)

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

75c86f04

Diff

@@ -124,7 +124,6 @@ infixl:25 " ≃+ " => AddEquiv
 namespace MulEquivClass
 
 variable (F)
-
 variable [EquivLike F M N]
 
 -- See note [lower instance priority]
@@ -148,7 +147,6 @@ instance (priority := 100) instMonoidHomClass
         _ = 1 := EquivLike.right_inv e 1 }
 
 variable [EquivLike F α β]
-
 variable {F}
 
 @[to_additive (attr := simp)]

chore: classify todo porting notes (#11216)

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

86f95a40

Diff

@@ -233,7 +233,7 @@ theorem coe_toEquiv (f : M ≃* N) : ⇑(f : M ≃ N) = f := rfl
 #align mul_equiv.coe_to_equiv MulEquiv.coe_toEquiv
 #align add_equiv.coe_to_equiv AddEquiv.coe_toEquiv
 
--- Porting note: todo: `MulHom.coe_mk` simplifies `↑f.toMulHom` to `f.toMulHom.toFun`,
+-- Porting note (#11215): TODO: `MulHom.coe_mk` simplifies `↑f.toMulHom` to `f.toMulHom.toFun`,
 -- not `f.toEquiv.toFun`; use higher priority as a workaround
 @[to_additive (attr := simp 1100)]
 theorem coe_toMulHom {f : M ≃* N} : (f.toMulHom : M → N) = f := rfl
@@ -608,7 +608,7 @@ noncomputable def ofBijective {M N F} [Mul M] [Mul N] [FunLike F M N] [MulHomCla
 #align mul_equiv.of_bijective_apply MulEquiv.ofBijective_apply
 #align add_equiv.of_bijective_apply AddEquiv.ofBijective_apply
 
--- Porting note: todo: simplify `symm_apply` to `surjInv`?
+-- Porting note (#11215): TODO: simplify `symm_apply` to `surjInv`?
 @[to_additive (attr := simp)]
 theorem ofBijective_apply_symm_apply {n : N} (f : M →* N) (hf : Bijective f) :
     f ((ofBijective f hf).symm n) = n := (ofBijective f hf).apply_symm_apply n

chore(Algebra/Group): Do not import GroupWithZero (#11202)

I am claiming that anything within the Algebra.Group folder should be additivisable, to the exception of MonoidHom.End maybe. This is not the case of NeZero, MonoidWithZero and MonoidWithZeroHom which were all imported to prove a few lemmas. Those lemmas are easily moved to another file.

c8969e40

Diff

@@ -149,22 +149,6 @@ instance (priority := 100) instMonoidHomClass
 
 variable [EquivLike F α β]
 
--- See note [lower instance priority]
-instance (priority := 100) toZeroHomClass
-    [MulZeroClass α] [MulZeroClass β] [MulEquivClass F α β] :
-    ZeroHomClass F α β where
-  map_zero := fun e =>
-    calc
-      e 0 = e 0 * e (EquivLike.inv e 0) := by rw [← map_mul, zero_mul]
-        _ = 0 := by simp
-
--- See note [lower instance priority]
-instance (priority := 100) toMonoidWithZeroHomClass
-    [MulZeroOneClass α] [MulZeroOneClass β] [MulEquivClass F α β] :
-    MonoidWithZeroHomClass F α β :=
-  { MulEquivClass.instMonoidHomClass F, MulEquivClass.toZeroHomClass F with }
-#align mul_equiv_class.to_monoid_with_zero_hom_class MulEquivClass.toMonoidWithZeroHomClass
-
 variable {F}
 
 @[to_additive (attr := simp)]

style: homogenise porting notes (#11145)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

converts "--porting note" into "-- Porting note";
converts "porting note" into "Porting note".

8be0b69c

Diff

@@ -249,7 +249,7 @@ theorem coe_toEquiv (f : M ≃* N) : ⇑(f : M ≃ N) = f := rfl
 #align mul_equiv.coe_to_equiv MulEquiv.coe_toEquiv
 #align add_equiv.coe_to_equiv AddEquiv.coe_toEquiv
 
--- porting note: todo: `MulHom.coe_mk` simplifies `↑f.toMulHom` to `f.toMulHom.toFun`,
+-- Porting note: todo: `MulHom.coe_mk` simplifies `↑f.toMulHom` to `f.toMulHom.toFun`,
 -- not `f.toEquiv.toFun`; use higher priority as a workaround
 @[to_additive (attr := simp 1100)]
 theorem coe_toMulHom {f : M ≃* N} : (f.toMulHom : M → N) = f := rfl
@@ -312,7 +312,7 @@ def symm {M N : Type*} [Mul M] [Mul N] (h : M ≃* N) : N ≃* M :=
 #align mul_equiv.symm MulEquiv.symm
 #align add_equiv.symm AddEquiv.symm
 
-@[to_additive] -- porting note: no longer a `simp`, see below
+@[to_additive] -- Porting note: no longer a `simp`, see below
 theorem invFun_eq_symm {f : M ≃* N} : f.invFun = f.symm := rfl
 #align mul_equiv.inv_fun_eq_symm MulEquiv.invFun_eq_symm
 -- Porting note: to_additive translated the name incorrectly in mathlib 3.
@@ -343,7 +343,7 @@ theorem toEquiv_symm (f : M ≃* N) : (f.symm : N ≃ M) = (f : M ≃ N).symm :=
 #align mul_equiv.to_equiv_symm MulEquiv.toEquiv_symm
 #align add_equiv.to_equiv_symm AddEquiv.toEquiv_symm
 
--- porting note: doesn't align with Mathlib 3 because `MulEquiv.mk` has a new signature
+-- Porting note: doesn't align with Mathlib 3 because `MulEquiv.mk` has a new signature
 @[to_additive (attr := simp)]
 theorem coe_mk (f : M ≃ N) (hf : ∀ x y, f (x * y) = f x * f y) : (mk f hf : M → N) = f := rfl
 #align mul_equiv.coe_mk MulEquiv.coe_mkₓ
@@ -624,7 +624,7 @@ noncomputable def ofBijective {M N F} [Mul M] [Mul N] [FunLike F M N] [MulHomCla
 #align mul_equiv.of_bijective_apply MulEquiv.ofBijective_apply
 #align add_equiv.of_bijective_apply AddEquiv.ofBijective_apply
 
--- porting note: todo: simplify `symm_apply` to `surjInv`?
+-- Porting note: todo: simplify `symm_apply` to `surjInv`?
 @[to_additive (attr := simp)]
 theorem ofBijective_apply_symm_apply {n : N} (f : M →* N) (hf : Bijective f) :
     f ((ofBijective f hf).symm n) = n := (ofBijective f hf).apply_symm_apply n
@@ -678,7 +678,7 @@ for multiplicative maps from a monoid to a commutative monoid.
 @[to_additive (attr := simps apply)
   "An additive analogue of `Equiv.arrowCongr`,
   for additive maps from an additive monoid to a commutative additive monoid."]
--- porting note: @[simps apply] removed because it was making a lemma which
+-- Porting note: @[simps apply] removed because it was making a lemma which
 -- wasn't in simp normal form.
 def monoidHomCongr {M N P Q} [MulOneClass M] [MulOneClass N] [CommMonoid P] [CommMonoid Q]
     (f : M ≃* N) (g : P ≃* Q) : (M →* P) ≃* (N →* Q) where
@@ -771,7 +771,7 @@ protected theorem map_div [Group G] [DivisionMonoid H] (h : G ≃* H) (x y : G)
 
 end MulEquiv
 
--- porting note: we want to add
+-- Porting note: we want to add
 -- `@[simps (config := .asFn)]`
 -- here, but it generates simp lemmas which aren't in simp normal form
 -- (they have `toFun` in)
@@ -794,7 +794,7 @@ def MulHom.toMulEquiv [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M) (h₁
 #align mul_hom.to_mul_equiv MulHom.toMulEquiv
 #align add_hom.to_add_equiv AddHom.toAddEquiv
 
--- porting note: the next two lemmas were added manually because `@[simps]` is generating
+-- Porting note: the next two lemmas were added manually because `@[simps]` is generating
 -- lemmas with `toFun` in
 @[to_additive (attr := simp)]
 theorem MulHom.toMulEquiv_apply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M)

chore: classify simp can do this porting notes (#10619)

Classify by adding issue number (#10618) to porting notes claiming anything semantically equivalent to simp can prove this or simp can simplify this.

de765f60

Diff

@@ -438,7 +438,7 @@ theorem symm_trans_apply (e₁ : M ≃* N) (e₂ : N ≃* P) (p : P) :
 #align mul_equiv.symm_trans_apply MulEquiv.symm_trans_apply
 #align add_equiv.symm_trans_apply AddEquiv.symm_trans_apply
 
--- Porting note: `simp` can prove this
+-- Porting note (#10618): `simp` can prove this
 @[to_additive]
 theorem apply_eq_iff_eq (e : M ≃* N) {x y : M} : e x = e y ↔ x = y :=
   e.injective.eq_iff
@@ -565,13 +565,13 @@ end Mul
 section MulOneClass
 variable [MulOneClass M] [MulOneClass N] [MulOneClass P]
 
--- Porting note: `simp` can prove this
+-- Porting note (#10618): `simp` can prove this
 @[to_additive]
 theorem coe_monoidHom_refl : (refl M : M →* M) = MonoidHom.id M := rfl
 #align mul_equiv.coe_monoid_hom_refl MulEquiv.coe_monoidHom_refl
 #align add_equiv.coe_add_monoid_hom_refl AddEquiv.coe_addMonoidHom_refl
 
--- Porting note: `simp` can prove this
+-- Porting note (#10618): `simp` can prove this
 @[to_additive]
 lemma coe_monoidHom_trans (e₁ : M ≃* N) (e₂ : N ≃* P) :
     (e₁.trans e₂ : M →* P) = (e₂ : N →* P).comp ↑e₁ := rfl

feat(Algebra/Group): Miscellaneous lemmas (#9387)

From LeanAPAP, LeanCamCombi and PFR

fabcf9d9

Diff

@@ -5,7 +5,6 @@ Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
 -/
 import Mathlib.Algebra.Group.Hom.Basic
 import Mathlib.Data.FunLike.Equiv
-import Mathlib.Data.Pi.Algebra
 import Mathlib.Logic.Equiv.Basic
 
 #align_import algebra.hom.equiv.basic from "leanprover-community/mathlib"@"1ac8d4304efba9d03fa720d06516fac845aa5353"
@@ -29,6 +28,7 @@ notation when treating the isomorphisms as maps.
 Equiv, MulEquiv, AddEquiv
 -/
 
+open Function
 
 variable {F α β A B M N P Q G H : Type*}
 
@@ -206,9 +206,11 @@ theorem MulEquivClass.toMulEquiv_injective [Mul α] [Mul β] [MulEquivClass F α
   fun _ _ e ↦ DFunLike.ext _ _ fun a ↦ congr_arg (fun e : α ≃* β ↦ e.toFun a) e
 
 namespace MulEquiv
+section Mul
+variable [Mul M] [Mul N] [Mul P] [Mul Q]
 
 @[to_additive]
-instance [Mul M] [Mul N] : EquivLike (M ≃* N) M N where
+instance : EquivLike (M ≃* N) M N where
   coe f := f.toFun
   inv f := f.invFun
   left_inv f := f.left_inv
@@ -220,15 +222,13 @@ instance [Mul M] [Mul N] : EquivLike (M ≃* N) M N where
     apply Equiv.coe_fn_injective h₁
 
 @[to_additive]
-instance [Mul M] [Mul N] : MulEquivClass (M ≃* N) M N where
+instance : MulEquivClass (M ≃* N) M N where
   map_mul f := f.map_mul'
 
 @[to_additive] -- shortcut instance that doesn't generate any subgoals
-instance [Mul M] [Mul N] : CoeFun (M ≃* N) fun _ => M → N where
+instance : CoeFun (M ≃* N) fun _ ↦ M → N where
   coe f := f
 
-variable [Mul M] [Mul N] [Mul P] [Mul Q]
-
 @[to_additive (attr := simp)]
 theorem toEquiv_eq_coe (f : M ≃* N) : f.toEquiv = f :=
   rfl
@@ -503,20 +503,6 @@ theorem self_trans_symm (e : M ≃* N) : e.trans e.symm = refl M :=
 #align mul_equiv.self_trans_symm MulEquiv.self_trans_symm
 #align add_equiv.self_trans_symm AddEquiv.self_trans_symm
 
--- Porting note: `simp` can prove this
-@[to_additive]
-theorem coe_monoidHom_refl {M} [MulOneClass M] : (refl M : M →* M) = MonoidHom.id M := rfl
-#align mul_equiv.coe_monoid_hom_refl MulEquiv.coe_monoidHom_refl
-#align add_equiv.coe_add_monoid_hom_refl AddEquiv.coe_addMonoidHom_refl
-
--- Porting note: `simp` can prove this
-@[to_additive]
-theorem coe_monoidHom_trans {M N P} [MulOneClass M] [MulOneClass N] [MulOneClass P]
-    (e₁ : M ≃* N) (e₂ : N ≃* P) :
-    (e₁.trans e₂ : M →* P) = (e₂ : N →* P).comp ↑e₁ := rfl
-#align mul_equiv.coe_monoid_hom_trans MulEquiv.coe_monoidHom_trans
-#align add_equiv.coe_add_monoid_hom_trans AddEquiv.coe_addMonoidHom_trans
-
 /-- Two multiplicative isomorphisms agree if they are defined by the
 same underlying function. -/
 @[to_additive (attr := ext)
@@ -570,29 +556,60 @@ instance {M N} [Unique M] [Unique N] [Mul M] [Mul N] : Unique (M ≃* N) where
   default := mulEquivOfUnique
   uniq _ := ext fun _ => Subsingleton.elim _ _
 
+end Mul
+
 /-!
 ## Monoids
 -/
 
+section MulOneClass
+variable [MulOneClass M] [MulOneClass N] [MulOneClass P]
+
+-- Porting note: `simp` can prove this
+@[to_additive]
+theorem coe_monoidHom_refl : (refl M : M →* M) = MonoidHom.id M := rfl
+#align mul_equiv.coe_monoid_hom_refl MulEquiv.coe_monoidHom_refl
+#align add_equiv.coe_add_monoid_hom_refl AddEquiv.coe_addMonoidHom_refl
+
+-- Porting note: `simp` can prove this
+@[to_additive]
+lemma coe_monoidHom_trans (e₁ : M ≃* N) (e₂ : N ≃* P) :
+    (e₁.trans e₂ : M →* P) = (e₂ : N →* P).comp ↑e₁ := rfl
+#align mul_equiv.coe_monoid_hom_trans MulEquiv.coe_monoidHom_trans
+#align add_equiv.coe_add_monoid_hom_trans AddEquiv.coe_addMonoidHom_trans
+
+@[to_additive (attr := simp)]
+lemma coe_monoidHom_comp_coe_monoidHom_symm (e : M ≃* N) :
+    (e : M →* N).comp e.symm = MonoidHom.id _ := by ext; simp
+
+@[to_additive (attr := simp)]
+lemma coe_monoidHom_symm_comp_coe_monoidHom (e : M ≃* N) :
+    (e.symm : N →* M).comp e = MonoidHom.id _ := by ext; simp
+
+@[to_additive]
+lemma comp_left_injective (e : M ≃* N) : Injective fun f : N →* P ↦ f.comp (e : M →* N) :=
+  LeftInverse.injective (g := fun f ↦ f.comp e.symm) fun f ↦ by simp [MonoidHom.comp_assoc]
+
+@[to_additive]
+lemma comp_right_injective (e : M ≃* N) : Injective fun f : P →* M ↦ (e : M →* N).comp f :=
+  LeftInverse.injective (g := (e.symm : N →* M).comp) fun f ↦ by simp [← MonoidHom.comp_assoc]
+
 /-- A multiplicative isomorphism of monoids sends `1` to `1` (and is hence a monoid isomorphism). -/
 @[to_additive
   "An additive isomorphism of additive monoids sends `0` to `0`
   (and is hence an additive monoid isomorphism)."]
-protected theorem map_one {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) : h 1 = 1 :=
-  _root_.map_one h
+protected theorem map_one (h : M ≃* N) : h 1 = 1 := _root_.map_one h
 #align mul_equiv.map_one MulEquiv.map_one
 #align add_equiv.map_zero AddEquiv.map_zero
 
 @[to_additive]
-protected theorem map_eq_one_iff {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) {x : M} :
-    h x = 1 ↔ x = 1 :=
+protected theorem map_eq_one_iff (h : M ≃* N) {x : M} : h x = 1 ↔ x = 1 :=
   MulEquivClass.map_eq_one_iff h
 #align mul_equiv.map_eq_one_iff MulEquiv.map_eq_one_iff
 #align add_equiv.map_eq_zero_iff AddEquiv.map_eq_zero_iff
 
 @[to_additive]
-theorem map_ne_one_iff {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) {x : M} :
-    h x ≠ 1 ↔ x ≠ 1 :=
+theorem map_ne_one_iff (h : M ≃* N) {x : M} : h x ≠ 1 ↔ x ≠ 1 :=
   MulEquivClass.map_ne_one_iff h
 #align mul_equiv.map_ne_one_iff MulEquiv.map_ne_one_iff
 #align add_equiv.map_ne_zero_iff AddEquiv.map_ne_zero_iff
@@ -600,8 +617,7 @@ theorem map_ne_one_iff {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) {x :
 /-- A bijective `Semigroup` homomorphism is an isomorphism -/
 @[to_additive (attr := simps! apply) "A bijective `AddSemigroup` homomorphism is an isomorphism"]
 noncomputable def ofBijective {M N F} [Mul M] [Mul N] [FunLike F M N] [MulHomClass F M N]
-(f : F) (hf : Function.Bijective f) :
-    M ≃* N :=
+    (f : F) (hf : Bijective f) : M ≃* N :=
   { Equiv.ofBijective f hf with map_mul' := map_mul f }
 #align mul_equiv.of_bijective MulEquiv.ofBijective
 #align add_equiv.of_bijective AddEquiv.ofBijective
@@ -610,9 +626,8 @@ noncomputable def ofBijective {M N F} [Mul M] [Mul N] [FunLike F M N] [MulHomCla
 
 -- porting note: todo: simplify `symm_apply` to `surjInv`?
 @[to_additive (attr := simp)]
-theorem ofBijective_apply_symm_apply {M N} [MulOneClass M] [MulOneClass N] {n : N} (f : M →* N)
-    (hf : Function.Bijective f) : f ((Equiv.ofBijective f hf).symm n) = n :=
-  (MulEquiv.ofBijective f hf).apply_symm_apply n
+theorem ofBijective_apply_symm_apply {n : N} (f : M →* N) (hf : Bijective f) :
+    f ((ofBijective f hf).symm n) = n := (ofBijective f hf).apply_symm_apply n
 #align mul_equiv.of_bijective_apply_symm_apply MulEquiv.ofBijective_apply_symm_apply
 #align add_equiv.of_bijective_apply_symm_apply AddEquiv.ofBijective_apply_symm_apply
 
@@ -621,25 +636,25 @@ as a multiplication-preserving function.
 -/
 @[to_additive "Extract the forward direction of an additive equivalence
   as an addition-preserving function."]
-def toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) : M →* N :=
+def toMonoidHom (h : M ≃* N) : M →* N :=
   { h with map_one' := h.map_one }
 #align mul_equiv.to_monoid_hom MulEquiv.toMonoidHom
 #align add_equiv.to_add_monoid_hom AddEquiv.toAddMonoidHom
 
 @[to_additive (attr := simp)]
-theorem coe_toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (e : M ≃* N) :
-    ⇑e.toMonoidHom = e := rfl
+theorem coe_toMonoidHom (e : M ≃* N) : ⇑e.toMonoidHom = e := rfl
 #align mul_equiv.coe_to_monoid_hom MulEquiv.coe_toMonoidHom
 #align add_equiv.coe_to_add_monoid_hom AddEquiv.coe_toAddMonoidHom
 
 set_option linter.deprecated false in
 @[to_additive]
-theorem toMonoidHom_injective {M N} [MulOneClass M] [MulOneClass N] :
-    Function.Injective (toMonoidHom : M ≃* N → M →* N) :=
+theorem toMonoidHom_injective : Injective (toMonoidHom : M ≃* N → M →* N) :=
   fun _ _ h => MulEquiv.ext (MonoidHom.ext_iff.1 h)
 #align mul_equiv.to_monoid_hom_injective MulEquiv.toMonoidHom_injective
 #align add_equiv.to_add_monoid_hom_injective AddEquiv.toAddMonoidHom_injective
 
+end MulOneClass
+
 /-- A multiplicative analogue of `Equiv.arrowCongr`,
 where the equivalence between the targets is multiplicative.
 -/

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

@@ -75,8 +75,8 @@ structure AddEquiv (A B : Type*) [Add A] [Add B] extends A ≃ B, AddHom A B
 
 /-- `AddEquivClass F A B` states that `F` is a type of addition-preserving morphisms.
 You should extend this class when you extend `AddEquiv`. -/
-class AddEquivClass (F : Type*) (A B : outParam (Type*)) [Add A] [Add B]
-    extends EquivLike F A B where
+class AddEquivClass (F : Type*) (A B : outParam Type*) [Add A] [Add B] [EquivLike F A B] : Prop
+    where
   /-- Preserves addition. -/
   map_add : ∀ (f : F) (a b), f (a + b) = f a + f b
 #align add_equiv_class AddEquivClass
@@ -107,9 +107,10 @@ add_decl_doc MulEquiv.toMulHom
 
 /-- `MulEquivClass F A B` states that `F` is a type of multiplication-preserving morphisms.
 You should extend this class when you extend `MulEquiv`. -/
+-- TODO: make this a synonym for MulHomClass?
 @[to_additive]
-class MulEquivClass (F : Type*) (A B : outParam (Type*)) [Mul A] [Mul B] extends
-  EquivLike F A B where
+class MulEquivClass (F : Type*) (A B : outParam Type*) [Mul A] [Mul B] [EquivLike F A B] : Prop
+    where
   /-- Preserves multiplication. -/
   map_mul : ∀ (f : F) (a b), f (a * b) = f a * f b
 #align mul_equiv_class MulEquivClass
@@ -124,11 +125,13 @@ namespace MulEquivClass
 
 variable (F)
 
+variable [EquivLike F M N]
+
 -- See note [lower instance priority]
 @[to_additive]
 instance (priority := 100) instMulHomClass (F : Type*)
-    [Mul M] [Mul N] [h : MulEquivClass F M N] : MulHomClass F M N :=
-  { h with coe := h.coe, coe_injective' := DFunLike.coe_injective' }
+    [Mul M] [Mul N] [EquivLike F M N] [h : MulEquivClass F M N] : MulHomClass F M N :=
+  { h with }
 
 -- See note [lower instance priority]
 @[to_additive]
@@ -136,14 +139,15 @@ instance (priority := 100) instMonoidHomClass
     [MulOneClass M] [MulOneClass N] [MulEquivClass F M N] :
     MonoidHomClass F M N :=
   { MulEquivClass.instMulHomClass F with
-    coe := fun _ => _,
     map_one := fun e =>
       calc
         e 1 = e 1 * 1 := (mul_one _).symm
-        _ = e 1 * e (MulEquivClass.toEquivLike.inv e (1 : N) : M) :=
-          congr_arg _ (MulEquivClass.toEquivLike.right_inv e 1).symm
-        _ = e (MulEquivClass.toEquivLike.inv e (1 : N)) := by rw [← map_mul, one_mul]
-        _ = 1 := MulEquivClass.toEquivLike.right_inv e 1 }
+        _ = e 1 * e (EquivLike.inv e (1 : N) : M) :=
+          congr_arg _ (EquivLike.right_inv e 1).symm
+        _ = e (EquivLike.inv e (1 : N)) := by rw [← map_mul, one_mul]
+        _ = 1 := EquivLike.right_inv e 1 }
+
+variable [EquivLike F α β]
 
 -- See note [lower instance priority]
 instance (priority := 100) toZeroHomClass
@@ -164,19 +168,23 @@ instance (priority := 100) toMonoidWithZeroHomClass
 variable {F}
 
 @[to_additive (attr := simp)]
-theorem map_eq_one_iff {M N} [MulOneClass M] [MulOneClass N] [MulEquivClass F M N] (h : F) {x : M} :
+theorem map_eq_one_iff {M N} [MulOneClass M] [MulOneClass N] [EquivLike F M N] [MulEquivClass F M N]
+    (h : F) {x : M} :
     h x = 1 ↔ x = 1 := _root_.map_eq_one_iff h (EquivLike.injective h)
 #align mul_equiv_class.map_eq_one_iff MulEquivClass.map_eq_one_iff
 #align add_equiv_class.map_eq_zero_iff AddEquivClass.map_eq_zero_iff
 
 @[to_additive]
-theorem map_ne_one_iff {M N} [MulOneClass M] [MulOneClass N] [MulEquivClass F M N] (h : F) {x : M} :
+theorem map_ne_one_iff {M N} [MulOneClass M] [MulOneClass N] [EquivLike F M N] [MulEquivClass F M N]
+    (h : F) {x : M} :
     h x ≠ 1 ↔ x ≠ 1 := _root_.map_ne_one_iff h (EquivLike.injective h)
 #align mul_equiv_class.map_ne_one_iff MulEquivClass.map_ne_one_iff
 #align add_equiv_class.map_ne_zero_iff AddEquivClass.map_ne_zero_iff
 
 end MulEquivClass
 
+variable [EquivLike F α β]
+
 /-- Turn an element of a type `F` satisfying `MulEquivClass F α β` into an actual
 `MulEquiv`. This is declared as the default coercion from `F` to `α ≃* β`. -/
 @[to_additive (attr := coe)
@@ -200,7 +208,7 @@ theorem MulEquivClass.toMulEquiv_injective [Mul α] [Mul β] [MulEquivClass F α
 namespace MulEquiv
 
 @[to_additive]
-instance [Mul M] [Mul N] : MulEquivClass (M ≃* N) M N where
+instance [Mul M] [Mul N] : EquivLike (M ≃* N) M N where
   coe f := f.toFun
   inv f := f.invFun
   left_inv f := f.left_inv
@@ -210,6 +218,9 @@ instance [Mul M] [Mul N] : MulEquivClass (M ≃* N) M N where
     cases g
     congr
     apply Equiv.coe_fn_injective h₁
+
+@[to_additive]
+instance [Mul M] [Mul N] : MulEquivClass (M ≃* N) M N where
   map_mul f := f.map_mul'
 
 @[to_additive] -- shortcut instance that doesn't generate any subgoals
@@ -588,7 +599,7 @@ theorem map_ne_one_iff {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) {x :
 
 /-- A bijective `Semigroup` homomorphism is an isomorphism -/
 @[to_additive (attr := simps! apply) "A bijective `AddSemigroup` homomorphism is an isomorphism"]
-noncomputable def ofBijective {M N F} [Mul M] [Mul N] [MulHomClass F M N]
+noncomputable def ofBijective {M N F} [Mul M] [Mul N] [FunLike F M N] [MulHomClass F M N]
 (f : F) (hf : Function.Bijective f) :
     M ≃* N :=
   { Equiv.ofBijective f hf with map_mul' := map_mul f }

chore(*): rename FunLike to DFunLike (#9785)

This prepares for the introduction of a non-dependent synonym of FunLike, which helps a lot with keeping #8386 readable.

This is entirely search-and-replace in 680197f combined with manual fixes in 4145626, e900597 and b8428f8. The commands that generated this change:

sed -i 's/\bFunLike\b/DFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\btoFunLike\b/toDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/import Mathlib.Data.DFunLike/import Mathlib.Data.FunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\bHom_FunLike\b/Hom_DFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean     
sed -i 's/\binstFunLike\b/instDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\bfunLike\b/instDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\btoo many metavariables to apply `fun_like.has_coe_to_fun`/too many metavariables to apply `DFunLike.hasCoeToFun`/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean

Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

82656743

Diff

@@ -128,7 +128,7 @@ variable (F)
 @[to_additive]
 instance (priority := 100) instMulHomClass (F : Type*)
     [Mul M] [Mul N] [h : MulEquivClass F M N] : MulHomClass F M N :=
-  { h with coe := h.coe, coe_injective' := FunLike.coe_injective' }
+  { h with coe := h.coe, coe_injective' := DFunLike.coe_injective' }
 
 -- See note [lower instance priority]
 @[to_additive]
@@ -195,7 +195,7 @@ instance [Mul α] [Mul β] [MulEquivClass F α β] : CoeTC F (α ≃* β) :=
 @[to_additive]
 theorem MulEquivClass.toMulEquiv_injective [Mul α] [Mul β] [MulEquivClass F α β] :
     Function.Injective ((↑) : F → α ≃* β) :=
-  fun _ _ e ↦ FunLike.ext _ _ fun a ↦ congr_arg (fun e : α ≃* β ↦ e.toFun a) e
+  fun _ _ e ↦ DFunLike.ext _ _ fun a ↦ congr_arg (fun e : α ≃* β ↦ e.toFun a) e
 
 namespace MulEquiv
 
@@ -482,13 +482,13 @@ theorem symm_comp_eq {α : Type*} (e : M ≃* N) (f : α → M) (g : α → N) :
 
 @[to_additive (attr := simp)]
 theorem symm_trans_self (e : M ≃* N) : e.symm.trans e = refl N :=
-  FunLike.ext _ _ e.apply_symm_apply
+  DFunLike.ext _ _ e.apply_symm_apply
 #align mul_equiv.symm_trans_self MulEquiv.symm_trans_self
 #align add_equiv.symm_trans_self AddEquiv.symm_trans_self
 
 @[to_additive (attr := simp)]
 theorem self_trans_symm (e : M ≃* N) : e.trans e.symm = refl M :=
-  FunLike.ext _ _ e.symm_apply_apply
+  DFunLike.ext _ _ e.symm_apply_apply
 #align mul_equiv.self_trans_symm MulEquiv.self_trans_symm
 #align add_equiv.self_trans_symm AddEquiv.self_trans_symm
 
@@ -511,13 +511,13 @@ same underlying function. -/
 @[to_additive (attr := ext)
   "Two additive isomorphisms agree if they are defined by the same underlying function."]
 theorem ext {f g : MulEquiv M N} (h : ∀ x, f x = g x) : f = g :=
-  FunLike.ext f g h
+  DFunLike.ext f g h
 #align mul_equiv.ext MulEquiv.ext
 #align add_equiv.ext AddEquiv.ext
 
 @[to_additive]
 theorem ext_iff {f g : MulEquiv M N} : f = g ↔ ∀ x, f x = g x :=
-  FunLike.ext_iff
+  DFunLike.ext_iff
 #align mul_equiv.ext_iff MulEquiv.ext_iff
 #align add_equiv.ext_iff AddEquiv.ext_iff
 
@@ -535,13 +535,13 @@ theorem mk_coe' (e : M ≃* N) (f h₁ h₂ h₃) : (MulEquiv.mk ⟨f, e, h₁,
 
 @[to_additive]
 protected theorem congr_arg {f : MulEquiv M N} {x x' : M} : x = x' → f x = f x' :=
-  FunLike.congr_arg f
+  DFunLike.congr_arg f
 #align mul_equiv.congr_arg MulEquiv.congr_arg
 #align add_equiv.congr_arg AddEquiv.congr_arg
 
 @[to_additive]
 protected theorem congr_fun {f g : MulEquiv M N} (h : f = g) (x : M) : f x = g x :=
-  FunLike.congr_fun h x
+  DFunLike.congr_fun h x
 #align mul_equiv.congr_fun MulEquiv.congr_fun
 #align add_equiv.congr_fun AddEquiv.congr_fun
 
@@ -762,8 +762,8 @@ def MulHom.toMulEquiv [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M) (h₁
     (h₂ : f.comp g = MulHom.id _) : M ≃* N where
   toFun := f
   invFun := g
-  left_inv := FunLike.congr_fun h₁
-  right_inv := FunLike.congr_fun h₂
+  left_inv := DFunLike.congr_fun h₁
+  right_inv := DFunLike.congr_fun h₂
   map_mul' := f.map_mul
 #align mul_hom.to_mul_equiv MulHom.toMulEquiv
 #align add_hom.to_add_equiv AddHom.toAddEquiv
@@ -798,8 +798,8 @@ def MonoidHom.toMulEquiv [MulOneClass M] [MulOneClass N] (f : M →* N) (g : N 
     (h₁ : g.comp f = MonoidHom.id _) (h₂ : f.comp g = MonoidHom.id _) : M ≃* N where
   toFun := f
   invFun := g
-  left_inv := FunLike.congr_fun h₁
-  right_inv := FunLike.congr_fun h₂
+  left_inv := DFunLike.congr_fun h₁
+  right_inv := DFunLike.congr_fun h₂
   map_mul' := f.map_mul
 #align monoid_hom.to_mul_equiv MonoidHom.toMulEquiv
 #align add_monoid_hom.to_add_equiv AddMonoidHom.toAddEquiv

chore(*): drop $/<| before fun (#9361)

Subset of #9319

3694e27d

Diff

@@ -195,7 +195,7 @@ instance [Mul α] [Mul β] [MulEquivClass F α β] : CoeTC F (α ≃* β) :=
 @[to_additive]
 theorem MulEquivClass.toMulEquiv_injective [Mul α] [Mul β] [MulEquivClass F α β] :
     Function.Injective ((↑) : F → α ≃* β) :=
-  fun _ _ e ↦ FunLike.ext _ _ <| fun a ↦ congr_arg (fun e : α ≃* β ↦ e.toFun a) e
+  fun _ _ e ↦ FunLike.ext _ _ fun a ↦ congr_arg (fun e : α ≃* β ↦ e.toFun a) e
 
 namespace MulEquiv

feat: Add API for AlgEquiv. (#8639)

Co-authored-by: Andrew Yang <36414270+erdOne@users.noreply.github.com>

bcd9607b

Diff

@@ -192,6 +192,11 @@ def MulEquivClass.toMulEquiv [Mul α] [Mul β] [MulEquivClass F α β] (f : F) :
 instance [Mul α] [Mul β] [MulEquivClass F α β] : CoeTC F (α ≃* β) :=
   ⟨MulEquivClass.toMulEquiv⟩
 
+@[to_additive]
+theorem MulEquivClass.toMulEquiv_injective [Mul α] [Mul β] [MulEquivClass F α β] :
+    Function.Injective ((↑) : F → α ≃* β) :=
+  fun _ _ e ↦ FunLike.ext _ _ <| fun a ↦ congr_arg (fun e : α ≃* β ↦ e.toFun a) e
+
 namespace MulEquiv
 
 @[to_additive]

feat(/Equiv/): Add symm_bijective lemmas next to symm_symms (#8444)

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: lines <34025592+linesthatinterlace@users.noreply.github.com>

e368f2a5

Diff

@@ -343,8 +343,8 @@ theorem symm_symm (f : M ≃* N) : f.symm.symm = f := rfl
 #align add_equiv.symm_symm AddEquiv.symm_symm
 
 @[to_additive]
-theorem symm_bijective : Function.Bijective (symm : M ≃* N → N ≃* M) :=
-  Equiv.bijective ⟨symm, symm, symm_symm, symm_symm⟩
+theorem symm_bijective : Function.Bijective (symm : (M ≃* N) → N ≃* M) :=
+  Function.bijective_iff_has_inverse.mpr ⟨_, symm_symm, symm_symm⟩
 #align mul_equiv.symm_bijective MulEquiv.symm_bijective
 #align add_equiv.symm_bijective AddEquiv.symm_bijective

feat: measurability of uniqueElim and piFinsetUnion (#8249)

The extra import doesn't add any additional imports transitively
Also use implicit arguments for some MeasurableSpace arguments for consistency with other lemmas.
Redefine Equiv.piSubsingleton and MulEquiv.piSubsingleton to Equiv.piUnique and MulEquiv.piUnique.

76efc30c

Diff

@@ -703,20 +703,20 @@ theorem piCongrRight_trans {η : Type*} {Ms Ns Ps : η → Type*} [∀ j, Mul (M
 #align mul_equiv.Pi_congr_right_trans MulEquiv.piCongrRight_trans
 #align add_equiv.Pi_congr_right_trans AddEquiv.piCongrRight_trans
 
-/-- A family indexed by a nonempty subsingleton type is equivalent to the element at the single
-index. -/
+/-- A family indexed by a type with a unique element
+is `MulEquiv` to the element at the single index. -/
 @[to_additive (attr := simps!)
-  "A family indexed by a nonempty subsingleton type is
-  equivalent to the element at the single index."]
-def piSubsingleton {ι : Type*} (M : ι → Type*) [∀ j, Mul (M j)] [Subsingleton ι]
-    (i : ι) : (∀ j, M j) ≃* M i :=
-  { Equiv.piSubsingleton M i with map_mul' := fun _ _ => Pi.mul_apply _ _ _ }
-#align mul_equiv.Pi_subsingleton MulEquiv.piSubsingleton
-#align add_equiv.Pi_subsingleton AddEquiv.piSubsingleton
-#align mul_equiv.Pi_subsingleton_apply MulEquiv.piSubsingleton_apply
-#align add_equiv.Pi_subsingleton_apply AddEquiv.piSubsingleton_apply
-#align mul_equiv.Pi_subsingleton_symm_apply MulEquiv.piSubsingleton_symm_apply
-#align add_equiv.Pi_subsingleton_symm_apply AddEquiv.piSubsingleton_symm_apply
+  "A family indexed by a type with a unique element
+  is `AddEquiv` to the element at the single index."]
+def piUnique {ι : Type*} (M : ι → Type*) [∀ j, Mul (M j)] [Unique ι] :
+    (∀ j, M j) ≃* M default :=
+  { Equiv.piUnique M with map_mul' := fun _ _ => Pi.mul_apply _ _ _ }
+#align mul_equiv.Pi_subsingleton MulEquiv.piUnique
+#align add_equiv.Pi_subsingleton AddEquiv.piUnique
+#align mul_equiv.Pi_subsingleton_apply MulEquiv.piUnique_apply
+#align add_equiv.Pi_subsingleton_apply AddEquiv.piUnique_apply
+#align mul_equiv.Pi_subsingleton_symm_apply MulEquiv.piUnique_symm_apply
+#align add_equiv.Pi_subsingleton_symm_apply AddEquiv.piUnique_symm_apply
 
 /-!
 # Groups

https://github.com/leanprover-community/mathlib4/blob/4055c8b471380825f07416b12cb0cf266da44d84/Mathlib/Tactic/Simps/Basic.lean#L843-L851

style: shorten simps configurations (#8296)

Use .asFn and .lemmasOnly as simps configuration options.

For reference, these are defined here:

e0637173

Diff

@@ -741,7 +741,7 @@ protected theorem map_div [Group G] [DivisionMonoid H] (h : G ≃* H) (x y : G)
 end MulEquiv
 
 -- porting note: we want to add
--- `@[simps (config := { fullyApplied := false })]`
+-- `@[simps (config := .asFn)]`
 -- here, but it generates simp lemmas which aren't in simp normal form
 -- (they have `toFun` in)
 /-- Given a pair of multiplicative homomorphisms `f`, `g` such that `g.comp f = id` and
@@ -784,7 +784,7 @@ theorem MulHom.toMulEquiv_symm_apply [Mul M] [Mul N] (f : M →ₙ* N) (g : N 
 /-- Given a pair of monoid homomorphisms `f`, `g` such that `g.comp f = id` and `f.comp g = id`,
 returns a multiplicative equivalence with `toFun = f` and `invFun = g`.  This constructor is
 useful if the underlying type(s) have specialized `ext` lemmas for monoid homomorphisms. -/
-@[to_additive (attr := simps (config := { fullyApplied := false }))
+@[to_additive (attr := simps (config := .asFn))
   "Given a pair of additive monoid homomorphisms `f`, `g` such that `g.comp f = id`
   and `f.comp g = id`, returns an additive equivalence with `toFun = f` and `invFun = g`.  This
   constructor is useful if the underlying type(s) have specialized `ext` lemmas for additive
@@ -810,7 +810,7 @@ section InvolutiveInv
 variable (G) [InvolutiveInv G]
 
 /-- Inversion on a `Group` or `GroupWithZero` is a permutation of the underlying type. -/
-@[to_additive (attr := simps! (config := { fullyApplied := false }) apply)
+@[to_additive (attr := simps! (config := .asFn) apply)
     "Negation on an `AddGroup` is a permutation of the underlying type."]
 protected def inv : Perm G :=
   inv_involutive.toPerm _

refactor(Algebra/Hom): transpose Hom and file name (#8095)

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

92fe122e

Diff

@@ -3,10 +3,10 @@ Copyright (c) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
 -/
-import Mathlib.Algebra.Hom.Group.Basic
+import Mathlib.Algebra.Group.Hom.Basic
 import Mathlib.Data.FunLike.Equiv
-import Mathlib.Logic.Equiv.Basic
 import Mathlib.Data.Pi.Algebra
+import Mathlib.Logic.Equiv.Basic
 
 #align_import algebra.hom.equiv.basic from "leanprover-community/mathlib"@"1ac8d4304efba9d03fa720d06516fac845aa5353"

chore: exactly 4 spaces in theorems (#7328)

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

d3263b23

Diff

@@ -496,8 +496,8 @@ theorem coe_monoidHom_refl {M} [MulOneClass M] : (refl M : M →* M) = MonoidHom
 -- Porting note: `simp` can prove this
 @[to_additive]
 theorem coe_monoidHom_trans {M N P} [MulOneClass M] [MulOneClass N] [MulOneClass P]
-  (e₁ : M ≃* N) (e₂ : N ≃* P) :
-  (e₁.trans e₂ : M →* P) = (e₂ : N →* P).comp ↑e₁ := rfl
+    (e₁ : M ≃* N) (e₂ : N ≃* P) :
+    (e₁.trans e₂ : M →* P) = (e₂ : N →* P).comp ↑e₁ := rfl
 #align mul_equiv.coe_monoid_hom_trans MulEquiv.coe_monoidHom_trans
 #align add_equiv.coe_add_monoid_hom_trans AddEquiv.coe_addMonoidHom_trans
 
@@ -650,8 +650,7 @@ for multiplicative maps from a monoid to a commutative monoid.
 -- porting note: @[simps apply] removed because it was making a lemma which
 -- wasn't in simp normal form.
 def monoidHomCongr {M N P Q} [MulOneClass M] [MulOneClass N] [CommMonoid P] [CommMonoid Q]
-  (f : M ≃* N) (g : P ≃* Q) :
-  (M →* P) ≃* (N →* Q) where
+    (f : M ≃* N) (g : P ≃* Q) : (M →* P) ≃* (N →* Q) where
   toFun h := g.toMonoidHom.comp (h.comp f.symm.toMonoidHom)
   invFun k := g.symm.toMonoidHom.comp (k.comp f.toMonoidHom)
   left_inv h := by ext; simp
@@ -675,7 +674,7 @@ This is the `MulEquiv` version of `Equiv.piCongrRight`, and the dependent versio
   This is the `AddEquiv` version of `Equiv.piCongrRight`, and the dependent version of
   `AddEquiv.arrowCongr`."]
 def piCongrRight {η : Type*} {Ms Ns : η → Type*} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
-  (es : ∀ j, Ms j ≃* Ns j) : (∀ j, Ms j) ≃* ∀ j, Ns j :=
+    (es : ∀ j, Ms j ≃* Ns j) : (∀ j, Ms j) ≃* ∀ j, Ns j :=
   { Equiv.piCongrRight fun j => (es j).toEquiv with
     toFun := fun x j => es j (x j),
     invFun := fun x j => (es j).symm (x j),
@@ -693,14 +692,14 @@ theorem piCongrRight_refl {η : Type*} {Ms : η → Type*} [∀ j, Mul (Ms j)] :
 
 @[to_additive (attr := simp)]
 theorem piCongrRight_symm {η : Type*} {Ms Ns : η → Type*} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
-  (es : ∀ j, Ms j ≃* Ns j) : (piCongrRight es).symm = piCongrRight fun i => (es i).symm := rfl
+    (es : ∀ j, Ms j ≃* Ns j) : (piCongrRight es).symm = piCongrRight fun i => (es i).symm := rfl
 #align mul_equiv.Pi_congr_right_symm MulEquiv.piCongrRight_symm
 #align add_equiv.Pi_congr_right_symm AddEquiv.piCongrRight_symm
 
 @[to_additive (attr := simp)]
 theorem piCongrRight_trans {η : Type*} {Ms Ns Ps : η → Type*} [∀ j, Mul (Ms j)]
-  [∀ j, Mul (Ns j)] [∀ j, Mul (Ps j)] (es : ∀ j, Ms j ≃* Ns j) (fs : ∀ j, Ns j ≃* Ps j) :
-  (piCongrRight es).trans (piCongrRight fs) = piCongrRight fun i => (es i).trans (fs i) := rfl
+    [∀ j, Mul (Ns j)] [∀ j, Mul (Ps j)] (es : ∀ j, Ms j ≃* Ns j) (fs : ∀ j, Ns j ≃* Ps j) :
+    (piCongrRight es).trans (piCongrRight fs) = piCongrRight fun i => (es i).trans (fs i) := rfl
 #align mul_equiv.Pi_congr_right_trans MulEquiv.piCongrRight_trans
 #align add_equiv.Pi_congr_right_trans AddEquiv.piCongrRight_trans
 
@@ -710,7 +709,7 @@ index. -/
   "A family indexed by a nonempty subsingleton type is
   equivalent to the element at the single index."]
 def piSubsingleton {ι : Type*} (M : ι → Type*) [∀ j, Mul (M j)] [Subsingleton ι]
-  (i : ι) : (∀ j, M j) ≃* M i :=
+    (i : ι) : (∀ j, M j) ≃* M i :=
   { Equiv.piSubsingleton M i with map_mul' := fun _ _ => Pi.mul_apply _ _ _ }
 #align mul_equiv.Pi_subsingleton MulEquiv.piSubsingleton
 #align add_equiv.Pi_subsingleton AddEquiv.piSubsingleton
@@ -755,7 +754,7 @@ homomorphisms. -/
   constructor is useful if the underlying type(s) have specialized `ext` lemmas for additive
   homomorphisms."]
 def MulHom.toMulEquiv [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M) (h₁ : g.comp f = MulHom.id _)
-  (h₂ : f.comp g = MulHom.id _) : M ≃* N where
+    (h₂ : f.comp g = MulHom.id _) : M ≃* N where
   toFun := f
   invFun := g
   left_inv := FunLike.congr_fun h₁
@@ -791,7 +790,7 @@ useful if the underlying type(s) have specialized `ext` lemmas for monoid homomo
   constructor is useful if the underlying type(s) have specialized `ext` lemmas for additive
   monoid homomorphisms."]
 def MonoidHom.toMulEquiv [MulOneClass M] [MulOneClass N] (f : M →* N) (g : N →* M)
-  (h₁ : g.comp f = MonoidHom.id _) (h₂ : f.comp g = MonoidHom.id _) : M ≃* N where
+    (h₁ : g.comp f = MonoidHom.id _) (h₂ : f.comp g = MonoidHom.id _) : M ≃* N where
   toFun := f
   invFun := g
   left_inv := FunLike.congr_fun h₁

fix: add symm_map_mul to fix simp issue. (#7407)

Zulip thread

926c0c5f

Diff

@@ -281,10 +281,18 @@ def refl (M : Type*) [Mul M] : M ≃* M :=
 @[to_additive]
 instance : Inhabited (M ≃* M) := ⟨refl M⟩
 
+/-- An alias for `h.symm.map_mul`. Introduced to fix the issue in
+https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/!4.234183.20.60simps.60.20maximum.20recursion.20depth
+-/
+@[to_additive]
+lemma symm_map_mul {M N : Type*} [Mul M] [Mul N] (h : M ≃* N) (x y : N) :
+    h.symm (x * y) = h.symm x * h.symm y :=
+  (h.toMulHom.inverse h.toEquiv.symm h.left_inv h.right_inv).map_mul x y
+
 /-- The inverse of an isomorphism is an isomorphism. -/
 @[to_additive (attr := symm) "The inverse of an isomorphism is an isomorphism."]
 def symm {M N : Type*} [Mul M] [Mul N] (h : M ≃* N) : N ≃* M :=
-  ⟨h.toEquiv.symm, (h.toMulHom.inverse h.toEquiv.symm h.left_inv h.right_inv).map_mul⟩
+  ⟨h.toEquiv.symm, h.symm_map_mul⟩
 #align mul_equiv.symm MulEquiv.symm
 #align add_equiv.symm AddEquiv.symm
 
@@ -344,7 +352,7 @@ theorem symm_bijective : Function.Bijective (symm : M ≃* N → N ≃* M) :=
 -- because the signature of `MulEquiv.mk` has changed.
 @[to_additive (attr := simp)]
 theorem symm_mk (f : M ≃ N) (h) :
-    (MulEquiv.mk f h).symm = ⟨f.symm, (MulEquiv.mk f h).symm.map_mul'⟩ := rfl
+    (MulEquiv.mk f h).symm = ⟨f.symm, (MulEquiv.mk f h).symm_map_mul⟩ := rfl
 #align mul_equiv.symm_mk MulEquiv.symm_mkₓ
 #align add_equiv.symm_mk AddEquiv.symm_mkₓ

chore: exactly 4 spaces in subsequent lines for def (#7321)

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

11dbfb2b

Diff

@@ -622,7 +622,7 @@ where the equivalence between the targets is multiplicative.
 @[to_additive (attr := simps apply) "An additive analogue of `Equiv.arrowCongr`,
   where the equivalence between the targets is additive."]
 def arrowCongr {M N P Q : Type*} [Mul P] [Mul Q] (f : M ≃ N) (g : P ≃* Q) :
-  (M → P) ≃* (N → Q) where
+    (M → P) ≃* (N → Q) where
   toFun h n := g (h (f.symm n))
   invFun k m := g.symm (k (f m))
   left_inv h := by ext; simp

chore: exactly 4 spaces in subsequent lines (#7296)

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

43ed95ab

Diff

@@ -561,7 +561,7 @@ protected theorem map_one {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) :
 
 @[to_additive]
 protected theorem map_eq_one_iff {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) {x : M} :
-  h x = 1 ↔ x = 1 :=
+    h x = 1 ↔ x = 1 :=
   MulEquivClass.map_eq_one_iff h
 #align mul_equiv.map_eq_one_iff MulEquiv.map_eq_one_iff
 #align add_equiv.map_eq_zero_iff AddEquiv.map_eq_zero_iff
@@ -718,7 +718,7 @@ def piSubsingleton {ι : Type*} (M : ι → Type*) [∀ j, Mul (M j)] [Subsingle
 /-- A multiplicative equivalence of groups preserves inversion. -/
 @[to_additive "An additive equivalence of additive groups preserves negation."]
 protected theorem map_inv [Group G] [DivisionMonoid H] (h : G ≃* H) (x : G) :
-  h x⁻¹ = (h x)⁻¹ :=
+    h x⁻¹ = (h x)⁻¹ :=
   _root_.map_inv h x
 #align mul_equiv.map_inv MulEquiv.map_inv
 #align add_equiv.map_neg AddEquiv.map_neg
@@ -726,7 +726,7 @@ protected theorem map_inv [Group G] [DivisionMonoid H] (h : G ≃* H) (x : G) :
 /-- A multiplicative equivalence of groups preserves division. -/
 @[to_additive "An additive equivalence of additive groups preserves subtractions."]
 protected theorem map_div [Group G] [DivisionMonoid H] (h : G ≃* H) (x y : G) :
-  h (x / y) = h x / h y :=
+    h (x / y) = h x / h y :=
   _root_.map_div h x y
 #align mul_equiv.map_div MulEquiv.map_div
 #align add_equiv.map_sub AddEquiv.map_sub

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

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

0c7d6fa5

Diff

@@ -165,13 +165,13 @@ variable {F}
 
 @[to_additive (attr := simp)]
 theorem map_eq_one_iff {M N} [MulOneClass M] [MulOneClass N] [MulEquivClass F M N] (h : F) {x : M} :
-  h x = 1 ↔ x = 1 := _root_.map_eq_one_iff h (EquivLike.injective h)
+    h x = 1 ↔ x = 1 := _root_.map_eq_one_iff h (EquivLike.injective h)
 #align mul_equiv_class.map_eq_one_iff MulEquivClass.map_eq_one_iff
 #align add_equiv_class.map_eq_zero_iff AddEquivClass.map_eq_zero_iff
 
 @[to_additive]
 theorem map_ne_one_iff {M N} [MulOneClass M] [MulOneClass N] [MulEquivClass F M N] (h : F) {x : M} :
-  h x ≠ 1 ↔ x ≠ 1 := _root_.map_ne_one_iff h (EquivLike.injective h)
+    h x ≠ 1 ↔ x ≠ 1 := _root_.map_ne_one_iff h (EquivLike.injective h)
 #align mul_equiv_class.map_ne_one_iff MulEquivClass.map_ne_one_iff
 #align add_equiv_class.map_ne_zero_iff AddEquivClass.map_ne_zero_iff
 
@@ -344,7 +344,7 @@ theorem symm_bijective : Function.Bijective (symm : M ≃* N → N ≃* M) :=
 -- because the signature of `MulEquiv.mk` has changed.
 @[to_additive (attr := simp)]
 theorem symm_mk (f : M ≃ N) (h) :
-  (MulEquiv.mk f h).symm = ⟨f.symm, (MulEquiv.mk f h).symm.map_mul'⟩ := rfl
+    (MulEquiv.mk f h).symm = ⟨f.symm, (MulEquiv.mk f h).symm.map_mul'⟩ := rfl
 #align mul_equiv.symm_mk MulEquiv.symm_mkₓ
 #align add_equiv.symm_mk AddEquiv.symm_mkₓ
 
@@ -410,7 +410,7 @@ theorem trans_apply (e₁ : M ≃* N) (e₂ : N ≃* P) (m : M) : e₁.trans e
 
 @[to_additive (attr := simp)]
 theorem symm_trans_apply (e₁ : M ≃* N) (e₂ : N ≃* P) (p : P) :
-  (e₁.trans e₂).symm p = e₁.symm (e₂.symm p) := rfl
+    (e₁.trans e₂).symm p = e₁.symm (e₂.symm p) := rfl
 #align mul_equiv.symm_trans_apply MulEquiv.symm_trans_apply
 #align add_equiv.symm_trans_apply AddEquiv.symm_trans_apply
 
@@ -441,28 +441,28 @@ theorem eq_symm_apply (e : M ≃* N) {x y} : y = e.symm x ↔ e y = x :=
 
 @[to_additive]
 theorem eq_comp_symm {α : Type*} (e : M ≃* N) (f : N → α) (g : M → α) :
-  f = g ∘ e.symm ↔ f ∘ e = g :=
+    f = g ∘ e.symm ↔ f ∘ e = g :=
   e.toEquiv.eq_comp_symm f g
 #align mul_equiv.eq_comp_symm MulEquiv.eq_comp_symm
 #align add_equiv.eq_comp_symm AddEquiv.eq_comp_symm
 
 @[to_additive]
 theorem comp_symm_eq {α : Type*} (e : M ≃* N) (f : N → α) (g : M → α) :
-  g ∘ e.symm = f ↔ g = f ∘ e :=
+    g ∘ e.symm = f ↔ g = f ∘ e :=
   e.toEquiv.comp_symm_eq f g
 #align mul_equiv.comp_symm_eq MulEquiv.comp_symm_eq
 #align add_equiv.comp_symm_eq AddEquiv.comp_symm_eq
 
 @[to_additive]
 theorem eq_symm_comp {α : Type*} (e : M ≃* N) (f : α → M) (g : α → N) :
-  f = e.symm ∘ g ↔ e ∘ f = g :=
+    f = e.symm ∘ g ↔ e ∘ f = g :=
   e.toEquiv.eq_symm_comp f g
 #align mul_equiv.eq_symm_comp MulEquiv.eq_symm_comp
 #align add_equiv.eq_symm_comp AddEquiv.eq_symm_comp
 
 @[to_additive]
 theorem symm_comp_eq {α : Type*} (e : M ≃* N) (f : α → M) (g : α → N) :
-  e.symm ∘ g = f ↔ g = e ∘ f :=
+    e.symm ∘ g = f ↔ g = e ∘ f :=
   e.toEquiv.symm_comp_eq f g
 #align mul_equiv.symm_comp_eq MulEquiv.symm_comp_eq
 #align add_equiv.symm_comp_eq AddEquiv.symm_comp_eq
@@ -568,7 +568,7 @@ protected theorem map_eq_one_iff {M N} [MulOneClass M] [MulOneClass N] (h : M 
 
 @[to_additive]
 theorem map_ne_one_iff {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) {x : M} :
-  h x ≠ 1 ↔ x ≠ 1 :=
+    h x ≠ 1 ↔ x ≠ 1 :=
   MulEquivClass.map_ne_one_iff h
 #align mul_equiv.map_ne_one_iff MulEquiv.map_ne_one_iff
 #align add_equiv.map_ne_zero_iff AddEquiv.map_ne_zero_iff
@@ -604,14 +604,14 @@ def toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) : M →* N
 
 @[to_additive (attr := simp)]
 theorem coe_toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (e : M ≃* N) :
-  ⇑e.toMonoidHom = e := rfl
+    ⇑e.toMonoidHom = e := rfl
 #align mul_equiv.coe_to_monoid_hom MulEquiv.coe_toMonoidHom
 #align add_equiv.coe_to_add_monoid_hom AddEquiv.coe_toAddMonoidHom
 
 set_option linter.deprecated false in
 @[to_additive]
 theorem toMonoidHom_injective {M N} [MulOneClass M] [MulOneClass N] :
-  Function.Injective (toMonoidHom : M ≃* N → M →* N) :=
+    Function.Injective (toMonoidHom : M ≃* N → M →* N) :=
   fun _ _ h => MulEquiv.ext (MonoidHom.ext_iff.1 h)
 #align mul_equiv.to_monoid_hom_injective MulEquiv.toMonoidHom_injective
 #align add_equiv.to_add_monoid_hom_injective AddEquiv.toAddMonoidHom_injective
@@ -679,7 +679,7 @@ def piCongrRight {η : Type*} {Ms Ns : η → Type*} [∀ j, Mul (Ms j)] [∀ j,
 
 @[to_additive (attr := simp)]
 theorem piCongrRight_refl {η : Type*} {Ms : η → Type*} [∀ j, Mul (Ms j)] :
-  (piCongrRight fun j => MulEquiv.refl (Ms j)) = MulEquiv.refl _ := rfl
+    (piCongrRight fun j => MulEquiv.refl (Ms j)) = MulEquiv.refl _ := rfl
 #align mul_equiv.Pi_congr_right_refl MulEquiv.piCongrRight_refl
 #align add_equiv.Pi_congr_right_refl AddEquiv.piCongrRight_refl

chore: make fields of algebraic (iso)morphisms protected (#7150)

Pretty much all these fields are implementation details, and not intended as API. There is no point in open MonoidHom bringing toFun or map_mul' into the environment, as neither are the preferred way to spell those things.

fbed0880

Diff

@@ -205,7 +205,7 @@ instance [Mul M] [Mul N] : MulEquivClass (M ≃* N) M N where
     cases g
     congr
     apply Equiv.coe_fn_injective h₁
-  map_mul := map_mul'
+  map_mul f := f.map_mul'
 
 @[to_additive] -- shortcut instance that doesn't generate any subgoals
 instance [Mul M] [Mul N] : CoeFun (M ≃* N) fun _ => M → N where

refactor: split Algebra.Hom.Group and Algebra.Hom.Ring (#7094)

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

260cb506

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
 -/
-import Mathlib.Algebra.Hom.Group
+import Mathlib.Algebra.Hom.Group.Basic
 import Mathlib.Data.FunLike.Equiv
 import Mathlib.Logic.Equiv.Basic
 import Mathlib.Data.Pi.Algebra

feat: generalize algebraic pullback instances (#6536)

Generalizes RingEquiv.noZeroDivisors and RingEquiv.isDomain to MulEquiv

Adds Function.Injective.isLeft/RightCancelMulZero, MulEquiv.toZeroHomClass, and MulEquiv.isField (the last one is useful for #6309)

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

7f528029

Diff

@@ -143,18 +143,22 @@ instance (priority := 100) instMonoidHomClass
         _ = e 1 * e (MulEquivClass.toEquivLike.inv e (1 : N) : M) :=
           congr_arg _ (MulEquivClass.toEquivLike.right_inv e 1).symm
         _ = e (MulEquivClass.toEquivLike.inv e (1 : N)) := by rw [← map_mul, one_mul]
-        _ = 1 := MulEquivClass.toEquivLike.right_inv e 1
-         }
+        _ = 1 := MulEquivClass.toEquivLike.right_inv e 1 }
+
+-- See note [lower instance priority]
+instance (priority := 100) toZeroHomClass
+    [MulZeroClass α] [MulZeroClass β] [MulEquivClass F α β] :
+    ZeroHomClass F α β where
+  map_zero := fun e =>
+    calc
+      e 0 = e 0 * e (EquivLike.inv e 0) := by rw [← map_mul, zero_mul]
+        _ = 0 := by simp
 
 -- See note [lower instance priority]
 instance (priority := 100) toMonoidWithZeroHomClass
     [MulZeroOneClass α] [MulZeroOneClass β] [MulEquivClass F α β] :
-  MonoidWithZeroHomClass F α β :=
-  { MulEquivClass.instMonoidHomClass _ with
-    map_zero := fun e =>
-      calc
-        e 0 = e 0 * e (EquivLike.inv e 0) := by rw [← map_mul, zero_mul]
-        _ = 0 := by simp }
+    MonoidWithZeroHomClass F α β :=
+  { MulEquivClass.instMonoidHomClass F, MulEquivClass.toZeroHomClass F with }
 #align mul_equiv_class.to_monoid_with_zero_hom_class MulEquivClass.toMonoidWithZeroHomClass
 
 variable {F}

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

@@ -30,7 +30,7 @@ Equiv, MulEquiv, AddEquiv
 -/
 
 
-variable {F α β A B M N P Q G H : Type _}
+variable {F α β A B M N P Q G H : Type*}
 
 /-- Makes a `OneHom` inverse from the bijective inverse of a `OneHom` -/
 @[to_additive (attr := simps)
@@ -60,7 +60,7 @@ def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M)
 /-- The inverse of a bijective `MonoidHom` is a `MonoidHom`. -/
 @[to_additive (attr := simps)
   "The inverse of a bijective `AddMonoidHom` is an `AddMonoidHom`."]
-def MonoidHom.inverse {A B : Type _} [Monoid A] [Monoid B] (f : A →* B) (g : B → A)
+def MonoidHom.inverse {A B : Type*} [Monoid A] [Monoid B] (f : A →* B) (g : B → A)
     (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) : B →* A :=
   { (f : OneHom A B).inverse g h₁,
     (f : A →ₙ* B).inverse g h₁ h₂ with toFun := g }
@@ -70,12 +70,12 @@ def MonoidHom.inverse {A B : Type _} [Monoid A] [Monoid B] (f : A →* B) (g : B
 #align add_monoid_hom.inverse_apply AddMonoidHom.inverse_apply
 
 /-- `AddEquiv α β` is the type of an equiv `α ≃ β` which preserves addition. -/
-structure AddEquiv (A B : Type _) [Add A] [Add B] extends A ≃ B, AddHom A B
+structure AddEquiv (A B : Type*) [Add A] [Add B] extends A ≃ B, AddHom A B
 #align add_equiv AddEquiv
 
 /-- `AddEquivClass F A B` states that `F` is a type of addition-preserving morphisms.
 You should extend this class when you extend `AddEquiv`. -/
-class AddEquivClass (F : Type _) (A B : outParam (Type _)) [Add A] [Add B]
+class AddEquivClass (F : Type*) (A B : outParam (Type*)) [Add A] [Add B]
     extends EquivLike F A B where
   /-- Preserves addition. -/
   map_add : ∀ (f : F) (a b), f (a + b) = f a + f b
@@ -91,7 +91,7 @@ add_decl_doc AddEquiv.toAddHom
 
 /-- `MulEquiv α β` is the type of an equiv `α ≃ β` which preserves multiplication. -/
 @[to_additive]
-structure MulEquiv (M N : Type _) [Mul M] [Mul N] extends M ≃ N, M →ₙ* N
+structure MulEquiv (M N : Type*) [Mul M] [Mul N] extends M ≃ N, M →ₙ* N
 -- Porting note: remove when `to_additive` can do this
 -- https://github.com/leanprover-community/mathlib4/issues/660
 attribute [to_additive existing] MulEquiv.toMulHom
@@ -108,7 +108,7 @@ add_decl_doc MulEquiv.toMulHom
 /-- `MulEquivClass F A B` states that `F` is a type of multiplication-preserving morphisms.
 You should extend this class when you extend `MulEquiv`. -/
 @[to_additive]
-class MulEquivClass (F : Type _) (A B : outParam (Type _)) [Mul A] [Mul B] extends
+class MulEquivClass (F : Type*) (A B : outParam (Type*)) [Mul A] [Mul B] extends
   EquivLike F A B where
   /-- Preserves multiplication. -/
   map_mul : ∀ (f : F) (a b), f (a * b) = f a * f b
@@ -126,7 +126,7 @@ variable (F)
 
 -- See note [lower instance priority]
 @[to_additive]
-instance (priority := 100) instMulHomClass (F : Type _)
+instance (priority := 100) instMulHomClass (F : Type*)
     [Mul M] [Mul N] [h : MulEquivClass F M N] : MulHomClass F M N :=
   { h with coe := h.coe, coe_injective' := FunLike.coe_injective' }
 
@@ -269,7 +269,7 @@ protected theorem surjective (e : M ≃* N) : Function.Surjective e :=
 
 /-- The identity map is a multiplicative isomorphism. -/
 @[to_additive (attr := refl) "The identity map is an additive isomorphism."]
-def refl (M : Type _) [Mul M] : M ≃* M :=
+def refl (M : Type*) [Mul M] : M ≃* M :=
   { Equiv.refl _ with map_mul' := fun _ _ => rfl }
 #align mul_equiv.refl MulEquiv.refl
 #align add_equiv.refl AddEquiv.refl
@@ -279,7 +279,7 @@ instance : Inhabited (M ≃* M) := ⟨refl M⟩
 
 /-- The inverse of an isomorphism is an isomorphism. -/
 @[to_additive (attr := symm) "The inverse of an isomorphism is an isomorphism."]
-def symm {M N : Type _} [Mul M] [Mul N] (h : M ≃* N) : N ≃* M :=
+def symm {M N : Type*} [Mul M] [Mul N] (h : M ≃* N) : N ≃* M :=
   ⟨h.toEquiv.symm, (h.toMulHom.inverse h.toEquiv.symm h.left_inv h.right_inv).map_mul⟩
 #align mul_equiv.symm MulEquiv.symm
 #align add_equiv.symm AddEquiv.symm
@@ -436,28 +436,28 @@ theorem eq_symm_apply (e : M ≃* N) {x y} : y = e.symm x ↔ e y = x :=
 #align add_equiv.eq_symm_apply AddEquiv.eq_symm_apply
 
 @[to_additive]
-theorem eq_comp_symm {α : Type _} (e : M ≃* N) (f : N → α) (g : M → α) :
+theorem eq_comp_symm {α : Type*} (e : M ≃* N) (f : N → α) (g : M → α) :
   f = g ∘ e.symm ↔ f ∘ e = g :=
   e.toEquiv.eq_comp_symm f g
 #align mul_equiv.eq_comp_symm MulEquiv.eq_comp_symm
 #align add_equiv.eq_comp_symm AddEquiv.eq_comp_symm
 
 @[to_additive]
-theorem comp_symm_eq {α : Type _} (e : M ≃* N) (f : N → α) (g : M → α) :
+theorem comp_symm_eq {α : Type*} (e : M ≃* N) (f : N → α) (g : M → α) :
   g ∘ e.symm = f ↔ g = f ∘ e :=
   e.toEquiv.comp_symm_eq f g
 #align mul_equiv.comp_symm_eq MulEquiv.comp_symm_eq
 #align add_equiv.comp_symm_eq AddEquiv.comp_symm_eq
 
 @[to_additive]
-theorem eq_symm_comp {α : Type _} (e : M ≃* N) (f : α → M) (g : α → N) :
+theorem eq_symm_comp {α : Type*} (e : M ≃* N) (f : α → M) (g : α → N) :
   f = e.symm ∘ g ↔ e ∘ f = g :=
   e.toEquiv.eq_symm_comp f g
 #align mul_equiv.eq_symm_comp MulEquiv.eq_symm_comp
 #align add_equiv.eq_symm_comp AddEquiv.eq_symm_comp
 
 @[to_additive]
-theorem symm_comp_eq {α : Type _} (e : M ≃* N) (f : α → M) (g : α → N) :
+theorem symm_comp_eq {α : Type*} (e : M ≃* N) (f : α → M) (g : α → N) :
   e.symm ∘ g = f ↔ g = e ∘ f :=
   e.toEquiv.symm_comp_eq f g
 #align mul_equiv.symm_comp_eq MulEquiv.symm_comp_eq
@@ -617,7 +617,7 @@ where the equivalence between the targets is multiplicative.
 -/
 @[to_additive (attr := simps apply) "An additive analogue of `Equiv.arrowCongr`,
   where the equivalence between the targets is additive."]
-def arrowCongr {M N P Q : Type _} [Mul P] [Mul Q] (f : M ≃ N) (g : P ≃* Q) :
+def arrowCongr {M N P Q : Type*} [Mul P] [Mul Q] (f : M ≃ N) (g : P ≃* Q) :
   (M → P) ≃* (N → Q) where
   toFun h n := g (h (f.symm n))
   invFun k m := g.symm (k (f m))
@@ -662,7 +662,7 @@ This is the `MulEquiv` version of `Equiv.piCongrRight`, and the dependent versio
 
   This is the `AddEquiv` version of `Equiv.piCongrRight`, and the dependent version of
   `AddEquiv.arrowCongr`."]
-def piCongrRight {η : Type _} {Ms Ns : η → Type _} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
+def piCongrRight {η : Type*} {Ms Ns : η → Type*} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
   (es : ∀ j, Ms j ≃* Ns j) : (∀ j, Ms j) ≃* ∀ j, Ns j :=
   { Equiv.piCongrRight fun j => (es j).toEquiv with
     toFun := fun x j => es j (x j),
@@ -674,19 +674,19 @@ def piCongrRight {η : Type _} {Ms Ns : η → Type _} [∀ j, Mul (Ms j)] [∀
 #align add_equiv.Pi_congr_right_apply AddEquiv.piCongrRight_apply
 
 @[to_additive (attr := simp)]
-theorem piCongrRight_refl {η : Type _} {Ms : η → Type _} [∀ j, Mul (Ms j)] :
+theorem piCongrRight_refl {η : Type*} {Ms : η → Type*} [∀ j, Mul (Ms j)] :
   (piCongrRight fun j => MulEquiv.refl (Ms j)) = MulEquiv.refl _ := rfl
 #align mul_equiv.Pi_congr_right_refl MulEquiv.piCongrRight_refl
 #align add_equiv.Pi_congr_right_refl AddEquiv.piCongrRight_refl
 
 @[to_additive (attr := simp)]
-theorem piCongrRight_symm {η : Type _} {Ms Ns : η → Type _} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
+theorem piCongrRight_symm {η : Type*} {Ms Ns : η → Type*} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
   (es : ∀ j, Ms j ≃* Ns j) : (piCongrRight es).symm = piCongrRight fun i => (es i).symm := rfl
 #align mul_equiv.Pi_congr_right_symm MulEquiv.piCongrRight_symm
 #align add_equiv.Pi_congr_right_symm AddEquiv.piCongrRight_symm
 
 @[to_additive (attr := simp)]
-theorem piCongrRight_trans {η : Type _} {Ms Ns Ps : η → Type _} [∀ j, Mul (Ms j)]
+theorem piCongrRight_trans {η : Type*} {Ms Ns Ps : η → Type*} [∀ j, Mul (Ms j)]
   [∀ j, Mul (Ns j)] [∀ j, Mul (Ps j)] (es : ∀ j, Ms j ≃* Ns j) (fs : ∀ j, Ns j ≃* Ps j) :
   (piCongrRight es).trans (piCongrRight fs) = piCongrRight fun i => (es i).trans (fs i) := rfl
 #align mul_equiv.Pi_congr_right_trans MulEquiv.piCongrRight_trans
@@ -697,7 +697,7 @@ index. -/
 @[to_additive (attr := simps!)
   "A family indexed by a nonempty subsingleton type is
   equivalent to the element at the single index."]
-def piSubsingleton {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)] [Subsingleton ι]
+def piSubsingleton {ι : Type*} (M : ι → Type*) [∀ j, Mul (M j)] [Subsingleton ι]
   (i : ι) : (∀ j, M j) ≃* M i :=
   { Equiv.piSubsingleton M i with map_mul' := fun _ _ => Pi.mul_apply _ _ _ }
 #align mul_equiv.Pi_subsingleton MulEquiv.piSubsingleton

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

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

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

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

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

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

65a35f78

Diff

@@ -32,20 +32,20 @@ Equiv, MulEquiv, AddEquiv
 
 variable {F α β A B M N P Q G H : Type _}
 
-/-- Makes a `OneHom` inverse from the bijective inverse of a `OneHom` -/  
-@[to_additive (attr := simps) 
-  "Make a `ZeroHom` inverse from the bijective inverse of a `ZeroHom`"] 
-def OneHom.inverse [One M] [One N] 
-    (f : OneHom M N) (g : N → M) 
-    (h₁ : Function.LeftInverse g f) : 
-  OneHom N M := 
+/-- Makes a `OneHom` inverse from the bijective inverse of a `OneHom` -/
+@[to_additive (attr := simps)
+  "Make a `ZeroHom` inverse from the bijective inverse of a `ZeroHom`"]
+def OneHom.inverse [One M] [One N]
+    (f : OneHom M N) (g : N → M)
+    (h₁ : Function.LeftInverse g f) :
+  OneHom N M :=
   { toFun := g,
     map_one' := by rw [← f.map_one, h₁] }
 
 /-- Makes a multiplicative inverse from a bijection which preserves multiplication. -/
-@[to_additive (attr := simps) 
+@[to_additive (attr := simps)
   "Makes an additive inverse from a bijection which preserves addition."]
-def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M) 
+def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M)
     (h₁ : Function.LeftInverse g f)
     (h₂ : Function.RightInverse g f) : N →ₙ* M where
   toFun := g
@@ -58,12 +58,12 @@ def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M)
 #align add_hom.inverse AddHom.inverse
 
 /-- The inverse of a bijective `MonoidHom` is a `MonoidHom`. -/
-@[to_additive (attr := simps) 
+@[to_additive (attr := simps)
   "The inverse of a bijective `AddMonoidHom` is an `AddMonoidHom`."]
 def MonoidHom.inverse {A B : Type _} [Monoid A] [Monoid B] (f : A →* B) (g : B → A)
     (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) : B →* A :=
   { (f : OneHom A B).inverse g h₁,
-    (f : A →ₙ* B).inverse g h₁ h₂ with toFun := g } 
+    (f : A →ₙ* B).inverse g h₁ h₂ with toFun := g }
 #align monoid_hom.inverse MonoidHom.inverse
 #align add_monoid_hom.inverse AddMonoidHom.inverse
 #align monoid_hom.inverse_apply MonoidHom.inverse_apply
@@ -126,13 +126,14 @@ variable (F)
 
 -- See note [lower instance priority]
 @[to_additive]
-instance (priority := 100) (F : Type _)
+instance (priority := 100) instMulHomClass (F : Type _)
     [Mul M] [Mul N] [h : MulEquivClass F M N] : MulHomClass F M N :=
   { h with coe := h.coe, coe_injective' := FunLike.coe_injective' }
 
 -- See note [lower instance priority]
 @[to_additive]
-instance (priority := 100) [MulOneClass M] [MulOneClass N] [MulEquivClass F M N] :
+instance (priority := 100) instMonoidHomClass
+    [MulOneClass M] [MulOneClass N] [MulEquivClass F M N] :
     MonoidHomClass F M N :=
   { MulEquivClass.instMulHomClass F with
     coe := fun _ => _,

chore: remove 'Ported by' headers (#6018)

Briefly during the port we were adding "Ported by" headers, but only ~60 / 3000 files ended up with such a header.

I propose deleting them.

We could consider adding these uniformly via a script, as part of the great history rewrite...?

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

e8318a88

Diff

@@ -2,7 +2,6 @@
 Copyright (c) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
-Ported by: Winston Yin
 -/
 import Mathlib.Algebra.Hom.Group
 import Mathlib.Data.FunLike.Equiv

feat(Algebra.Ring.Equiv) : provide RingHom inverse (#5997)

Define:

OneHom.inverse (and its additive version)
NonUnitalRingHom.inverse
RingHom.inverse

Co-authored-by: Antoine Chambert-Loir <antoine.chambert-loir@math.univ-paris-diderot.fr>

30c87ba5

Diff

@@ -33,10 +33,22 @@ Equiv, MulEquiv, AddEquiv
 
 variable {F α β A B M N P Q G H : Type _}
 
+/-- Makes a `OneHom` inverse from the bijective inverse of a `OneHom` -/  
+@[to_additive (attr := simps) 
+  "Make a `ZeroHom` inverse from the bijective inverse of a `ZeroHom`"] 
+def OneHom.inverse [One M] [One N] 
+    (f : OneHom M N) (g : N → M) 
+    (h₁ : Function.LeftInverse g f) : 
+  OneHom N M := 
+  { toFun := g,
+    map_one' := by rw [← f.map_one, h₁] }
+
 /-- Makes a multiplicative inverse from a bijection which preserves multiplication. -/
-@[to_additive "Makes an additive inverse from a bijection which preserves addition."]
-def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M) (h₁ : Function.LeftInverse g f)
-  (h₂ : Function.RightInverse g f) : N →ₙ* M where
+@[to_additive (attr := simps) 
+  "Makes an additive inverse from a bijection which preserves addition."]
+def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M) 
+    (h₁ : Function.LeftInverse g f)
+    (h₂ : Function.RightInverse g f) : N →ₙ* M where
   toFun := g
   map_mul' x y :=
     calc
@@ -47,10 +59,12 @@ def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M) (h₁ : Funct
 #align add_hom.inverse AddHom.inverse
 
 /-- The inverse of a bijective `MonoidHom` is a `MonoidHom`. -/
-@[to_additive (attr := simps) "The inverse of a bijective `AddMonoidHom` is an `AddMonoidHom`."]
+@[to_additive (attr := simps) 
+  "The inverse of a bijective `AddMonoidHom` is an `AddMonoidHom`."]
 def MonoidHom.inverse {A B : Type _} [Monoid A] [Monoid B] (f : A →* B) (g : B → A)
-  (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) : B →* A :=
-  { (f : A →ₙ* B).inverse g h₁ h₂ with toFun := g, map_one' := by rw [← f.map_one, h₁] }
+    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) : B →* A :=
+  { (f : OneHom A B).inverse g h₁,
+    (f : A →ₙ* B).inverse g h₁ h₂ with toFun := g } 
 #align monoid_hom.inverse MonoidHom.inverse
 #align add_monoid_hom.inverse AddMonoidHom.inverse
 #align monoid_hom.inverse_apply MonoidHom.inverse_apply

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

@@ -3,17 +3,14 @@ Copyright (c) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
 Ported by: Winston Yin
-
-! This file was ported from Lean 3 source module algebra.hom.equiv.basic
-! leanprover-community/mathlib commit 1ac8d4304efba9d03fa720d06516fac845aa5353
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Hom.Group
 import Mathlib.Data.FunLike.Equiv
 import Mathlib.Logic.Equiv.Basic
 import Mathlib.Data.Pi.Algebra
 
+#align_import algebra.hom.equiv.basic from "leanprover-community/mathlib"@"1ac8d4304efba9d03fa720d06516fac845aa5353"
+
 /-!
 # Multiplicative and additive equivs

feat: add MulEquiv.toMulHom_eq_coe to normalize coercions (#5546)

There will probably be simpNF problems, waiting for CI.

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

d5ecb6d7

Diff

@@ -204,6 +204,11 @@ theorem toEquiv_eq_coe (f : M ≃* N) : f.toEquiv = f :=
 #align mul_equiv.to_equiv_eq_coe MulEquiv.toEquiv_eq_coe
 #align add_equiv.to_equiv_eq_coe AddEquiv.toEquiv_eq_coe
 
+-- Porting note: added, to simplify `f.toMulHom` back to the coercion via `MulHomClass.toMulHom`.
+@[to_additive (attr := simp)]
+theorem toMulHom_eq_coe (f : M ≃* N) : f.toMulHom = ↑f :=
+  rfl
+
 -- Porting note: `to_fun_eq_coe` no longer needed in Lean4
 #noalign mul_equiv.to_fun_eq_coe
 #noalign add_equiv.to_fun_eq_coe

chore: forward_port leanprover-community/mathlib#19169 (#5057)

The other files were already fixed in Lean4. I also tried doing a sweep of the rest of the files to make sure there was no more broken ones - it seems ok.

61d2c36d

Diff

@@ -5,7 +5,7 @@ Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
 Ported by: Winston Yin
 
 ! This file was ported from Lean 3 source module algebra.hom.equiv.basic
-! leanprover-community/mathlib commit 67f362670ed961bcb80239dc40ca18bcd4289c77
+! leanprover-community/mathlib commit 1ac8d4304efba9d03fa720d06516fac845aa5353
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/

chore: fix grammar 1/3 (#5001)

All of these are doc fixes

d8caa37d

Diff

@@ -75,7 +75,7 @@ class AddEquivClass (F : Type _) (A B : outParam (Type _)) [Add A] [Add B]
 add_decl_doc AddEquiv.toEquiv
 #align add_equiv.to_equiv AddEquiv.toEquiv
 
-/-- The `AddHom` underlying a `AddEquiv`. -/
+/-- The `AddHom` underlying an `AddEquiv`. -/
 add_decl_doc AddEquiv.toAddHom
 #align add_equiv.to_add_hom AddEquiv.toAddHom
 
@@ -718,7 +718,7 @@ end MulEquiv
 -- here, but it generates simp lemmas which aren't in simp normal form
 -- (they have `toFun` in)
 /-- Given a pair of multiplicative homomorphisms `f`, `g` such that `g.comp f = id` and
-`f.comp g = id`, returns an multiplicative equivalence with `toFun = f` and `invFun = g`. This
+`f.comp g = id`, returns a multiplicative equivalence with `toFun = f` and `invFun = g`. This
 constructor is useful if the underlying type(s) have specialized `ext` lemmas for multiplicative
 homomorphisms. -/
 @[to_additive
@@ -755,7 +755,7 @@ theorem MulHom.toMulEquiv_symm_apply [Mul M] [Mul N] (f : M →ₙ* N) (g : N 
 #align add_hom.to_add_equiv_symm_apply AddHom.toAddEquiv_symm_apply
 
 /-- Given a pair of monoid homomorphisms `f`, `g` such that `g.comp f = id` and `f.comp g = id`,
-returns an multiplicative equivalence with `toFun = f` and `invFun = g`.  This constructor is
+returns a multiplicative equivalence with `toFun = f` and `invFun = g`.  This constructor is
 useful if the underlying type(s) have specialized `ext` lemmas for monoid homomorphisms. -/
 @[to_additive (attr := simps (config := { fullyApplied := false }))
   "Given a pair of additive monoid homomorphisms `f`, `g` such that `g.comp f = id`

chore: formatting issues (#4947)

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

5068808d

Diff

@@ -168,7 +168,7 @@ end MulEquivClass
 "Turn an element of a type `F` satisfying `AddEquivClass F α β` into an actual
 `AddEquiv`. This is declared as the default coercion from `F` to `α ≃+ β`."]
 def MulEquivClass.toMulEquiv [Mul α] [Mul β] [MulEquivClass F α β] (f : F) : α ≃* β :=
-{ (f : α ≃ β), (f : α →ₙ* β) with }
+  { (f : α ≃ β), (f : α →ₙ* β) with }
 
 /-- Any type satisfying `MulEquivClass` can be cast into `MulEquiv` via
 `MulEquivClass.toMulEquiv`. -/

chore: reenable eta, bump to nightly 2023-05-16 (#3414)

Now that leanprover/lean4#2210 has been merged, this PR:

removes all the set_option synthInstance.etaExperiment true commands (and some etaExperiment% term elaborators)
removes many but not quite all set_option maxHeartbeats commands
makes various other changes required to cope with leanprover/lean4#2210.

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Matthew Ballard <matt@mrb.email>

a6e1045f

Diff

@@ -192,6 +192,10 @@ instance [Mul M] [Mul N] : MulEquivClass (M ≃* N) M N where
     apply Equiv.coe_fn_injective h₁
   map_mul := map_mul'
 
+@[to_additive] -- shortcut instance that doesn't generate any subgoals
+instance [Mul M] [Mul N] : CoeFun (M ≃* N) fun _ => M → N where
+  coe f := f
+
 variable [Mul M] [Mul N] [Mul P] [Mul Q]
 
 @[to_additive (attr := simp)]

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

@@ -46,7 +46,6 @@ def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M) (h₁ : Funct
       g (x * y) = g (f (g x) * f (g y)) := by rw [h₂ x, h₂ y]
       _ = g (f (g x * g y)) := by rw [f.map_mul]
       _ = g x * g y := h₁ _
-
 #align mul_hom.inverse MulHom.inverse
 #align add_hom.inverse AddHom.inverse

chore: bump to nightly-2023-04-11 (#3139)

1cd8b316

Diff

@@ -117,14 +117,14 @@ variable (F)
 
 -- See note [lower instance priority]
 @[to_additive]
-instance (priority := 100) (F : Type _) {M N : Type _}
-    {_ : Mul M} {_ : Mul N} [h : MulEquivClass F M N] : MulHomClass F M N :=
+instance (priority := 100) (F : Type _)
+    [Mul M] [Mul N] [h : MulEquivClass F M N] : MulHomClass F M N :=
   { h with coe := h.coe, coe_injective' := FunLike.coe_injective' }
 
 -- See note [lower instance priority]
 @[to_additive]
-instance (priority := 100) {_ : MulOneClass M} {_ : MulOneClass N} [MulEquivClass F M N] :
-  MonoidHomClass F M N :=
+instance (priority := 100) [MulOneClass M] [MulOneClass N] [MulEquivClass F M N] :
+    MonoidHomClass F M N :=
   { MulEquivClass.instMulHomClass F with
     coe := fun _ => _,
     map_one := fun e =>
@@ -138,7 +138,7 @@ instance (priority := 100) {_ : MulOneClass M} {_ : MulOneClass N} [MulEquivClas
 
 -- See note [lower instance priority]
 instance (priority := 100) toMonoidWithZeroHomClass
-  {α β : Type _} {_ : MulZeroOneClass α} {_ : MulZeroOneClass β} [MulEquivClass F α β] :
+    [MulZeroOneClass α] [MulZeroOneClass β] [MulEquivClass F α β] :
   MonoidWithZeroHomClass F α β :=
   { MulEquivClass.instMonoidHomClass _ with
     map_zero := fun e =>

fix: add back lemmas deleted during porting (#3035)

These lemmas are not tautologies, despite the assumption that they were. We know this because otherwise CI would fail.

After adding these back, a few statements downstream need to change from statements about toEquiv to statements about EquivLike.toEquiv.

fa1b54f8

Diff

@@ -195,15 +195,18 @@ instance [Mul M] [Mul N] : MulEquivClass (M ≃* N) M N where
 
 variable [Mul M] [Mul N] [Mul P] [Mul Q]
 
--- Porting note: `to_equiv_eq_coe` no longer needed in Lean4
-#noalign mul_equiv.to_equiv_eq_coe
-#noalign add_equiv.to_equiv_eq_coe
+@[to_additive (attr := simp)]
+theorem toEquiv_eq_coe (f : M ≃* N) : f.toEquiv = f :=
+  rfl
+#align mul_equiv.to_equiv_eq_coe MulEquiv.toEquiv_eq_coe
+#align add_equiv.to_equiv_eq_coe AddEquiv.toEquiv_eq_coe
+
 -- Porting note: `to_fun_eq_coe` no longer needed in Lean4
 #noalign mul_equiv.to_fun_eq_coe
 #noalign add_equiv.to_fun_eq_coe
 
 @[to_additive (attr := simp)]
-theorem coe_toEquiv (f : M ≃* N) : (f.toEquiv : M → N) = f := rfl
+theorem coe_toEquiv (f : M ≃* N) : ⇑(f : M ≃ N) = f := rfl
 #align mul_equiv.coe_to_equiv MulEquiv.coe_toEquiv
 #align add_equiv.coe_to_equiv AddEquiv.coe_toEquiv
 
@@ -269,7 +272,7 @@ theorem invFun_eq_symm {f : M ≃* N} : f.invFun = f.symm := rfl
 #align add_equiv.neg_fun_eq_symm AddEquiv.invFun_eq_symm
 
 @[to_additive (attr := simp)]
-theorem coe_toEquiv_symm (f : M ≃* N) : (f.toEquiv.symm : N → M) = f.symm := rfl
+theorem coe_toEquiv_symm (f : M ≃* N) : ((f : M ≃ N).symm : N → M) = f.symm := rfl
 
 @[to_additive (attr := simp)]
 theorem equivLike_inv_eq_symm (f : M ≃* N) : EquivLike.inv f = f.symm := rfl
@@ -278,7 +281,7 @@ theorem equivLike_inv_eq_symm (f : M ≃* N) : EquivLike.inv f = f.symm := rfl
 -- in the whole file.
 
 /-- See Note [custom simps projection] -/
-@[to_additive "See Note custom simps projection"]
+@[to_additive "See Note [custom simps projection]"] -- this comment fixes the syntax highlighting "
 def Simps.symm_apply (e : M ≃* N) : N → M :=
   e.symm
 #align mul_equiv.simps.symm_apply MulEquiv.Simps.symm_apply
@@ -289,7 +292,7 @@ initialize_simps_projections AddEquiv (toFun → apply, invFun → symm_apply)
 initialize_simps_projections MulEquiv (toFun → apply, invFun → symm_apply)
 
 @[to_additive (attr := simp)]
-theorem toEquiv_symm (f : M ≃* N) : f.symm.toEquiv = f.toEquiv.symm := rfl
+theorem toEquiv_symm (f : M ≃* N) : (f.symm : N ≃ M) = (f : M ≃ N).symm := rfl
 #align mul_equiv.to_equiv_symm MulEquiv.toEquiv_symm
 #align add_equiv.to_equiv_symm AddEquiv.toEquiv_symm

feat: initialize_simps_projections automatically finds coercions (#2045)

initialize_simps_projections automatically find coercions if there is a Funlike or SetLike instance defined by one of the projections.
Some improvements compared to Lean 3:
- Find coercions even if it is defined by a field of a parent structure
- Find SetLike coercions

Not yet implemented (and rarely - if ever - used in mathlib3):

Automatic custom projections for algebraic notation (like +,*,...)

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

b5daaa7b

Diff

@@ -277,10 +277,6 @@ theorem equivLike_inv_eq_symm (f : M ≃* N) : EquivLike.inv f = f.symm := rfl
 -- we don't hyperlink the note in the additive version, since that breaks syntax highlighting
 -- in the whole file.
 
--- Porting note: in mathlib3 we didn't need the `Simps.apply` hint.
-/-- See Note [custom simps projection] -/
-@[to_additive "See Note custom simps projection"]
-def Simps.apply (e : M ≃* N) : M → N := e
 /-- See Note [custom simps projection] -/
 @[to_additive "See Note custom simps projection"]
 def Simps.symm_apply (e : M ≃* N) : N → M :=

fix: replace symmApply by symm_apply (#2560)

9aade17b

Diff

@@ -283,14 +283,14 @@ theorem equivLike_inv_eq_symm (f : M ≃* N) : EquivLike.inv f = f.symm := rfl
 def Simps.apply (e : M ≃* N) : M → N := e
 /-- See Note [custom simps projection] -/
 @[to_additive "See Note custom simps projection"]
-def Simps.symmApply (e : M ≃* N) : N → M :=
+def Simps.symm_apply (e : M ≃* N) : N → M :=
   e.symm
-#align mul_equiv.simps.symm_apply MulEquiv.Simps.symmApply
-#align add_equiv.simps.symm_apply AddEquiv.Simps.symmApply
+#align mul_equiv.simps.symm_apply MulEquiv.Simps.symm_apply
+#align add_equiv.simps.symm_apply AddEquiv.Simps.symm_apply
 
-initialize_simps_projections AddEquiv (toFun → apply, invFun → symmApply)
+initialize_simps_projections AddEquiv (toFun → apply, invFun → symm_apply)
 
-initialize_simps_projections MulEquiv (toFun → apply, invFun → symmApply)
+initialize_simps_projections MulEquiv (toFun → apply, invFun → symm_apply)
 
 @[to_additive (attr := simp)]
 theorem toEquiv_symm (f : M ≃* N) : f.symm.toEquiv = f.toEquiv.symm := rfl
@@ -686,8 +686,8 @@ def piSubsingleton {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)] [Subsing
 #align add_equiv.Pi_subsingleton AddEquiv.piSubsingleton
 #align mul_equiv.Pi_subsingleton_apply MulEquiv.piSubsingleton_apply
 #align add_equiv.Pi_subsingleton_apply AddEquiv.piSubsingleton_apply
-#align mul_equiv.Pi_subsingleton_symm_apply MulEquiv.piSubsingleton_symmApply
-#align add_equiv.Pi_subsingleton_symm_apply AddEquiv.piSubsingleton_symmApply
+#align mul_equiv.Pi_subsingleton_symm_apply MulEquiv.piSubsingleton_symm_apply
+#align add_equiv.Pi_subsingleton_symm_apply AddEquiv.piSubsingleton_symm_apply
 
 /-!
 # Groups
@@ -745,12 +745,12 @@ theorem MulHom.toMulEquiv_apply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ*
 #align add_hom.to_add_equiv_apply AddHom.toAddEquiv_apply
 
 @[to_additive (attr := simp)]
-theorem MulHom.toMulEquiv_symmApply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M)
+theorem MulHom.toMulEquiv_symm_apply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M)
     (h₁ : g.comp f = MulHom.id _) (h₂ : f.comp g = MulHom.id _) :
     (MulEquiv.symm (MulHom.toMulEquiv f g h₁ h₂) : N → M) = ↑g :=
   rfl
-#align mul_hom.to_mul_equiv_symm_apply MulHom.toMulEquiv_symmApply
-#align add_hom.to_add_equiv_symm_apply AddHom.toAddEquiv_symmApply
+#align mul_hom.to_mul_equiv_symm_apply MulHom.toMulEquiv_symm_apply
+#align add_hom.to_add_equiv_symm_apply AddHom.toAddEquiv_symm_apply
 
 /-- Given a pair of monoid homomorphisms `f`, `g` such that `g.comp f = id` and `f.comp g = id`,
 returns an multiplicative equivalence with `toFun = f` and `invFun = g`.  This constructor is
@@ -771,8 +771,8 @@ def MonoidHom.toMulEquiv [MulOneClass M] [MulOneClass N] (f : M →* N) (g : N 
 #align add_monoid_hom.to_add_equiv AddMonoidHom.toAddEquiv
 #align monoid_hom.to_mul_equiv_apply MonoidHom.toMulEquiv_apply
 #align add_monoid_hom.to_add_equiv_apply AddMonoidHom.toAddEquiv_apply
-#align monoid_hom.to_mul_equiv_symm_apply MonoidHom.toMulEquiv_symmApply
-#align add_monoid_hom.to_add_equiv_symm_apply AddMonoidHom.toAddEquiv_symmApply
+#align monoid_hom.to_mul_equiv_symm_apply MonoidHom.toMulEquiv_symm_apply
+#align add_monoid_hom.to_add_equiv_symm_apply AddMonoidHom.toAddEquiv_symm_apply
 
 namespace Equiv

feat: simps uses fields of parent structures (#2042)

initialize_simps_projections now by default generates all projections of all parent structures, and doesn't generate the projections to those parent structures.
You can also rename a nested projection directly, without having to specify intermediate parent structures
Added the option to turn the default behavior off (done in e.g. TwoPointed)

Internal changes:

Move most declarations to the Simps namespace, and shorten their names
Restructure ParsedProjectionData to avoid the bug reported here (and to another bug where it seemed that the wrong data was inserted in ParsedProjectionData, but it was hard to minimize because of all the crashes). If we manage to fix the bug in that Zulip thread, I'll see if I can track down the other bug in commit 97454284

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

b21620a7

Diff

@@ -288,9 +288,9 @@ def Simps.symmApply (e : M ≃* N) : N → M :=
 #align mul_equiv.simps.symm_apply MulEquiv.Simps.symmApply
 #align add_equiv.simps.symm_apply AddEquiv.Simps.symmApply
 
-initialize_simps_projections AddEquiv (toEquiv_toFun → apply, toEquiv_invFun → symmApply, -toEquiv)
+initialize_simps_projections AddEquiv (toFun → apply, invFun → symmApply)
 
-initialize_simps_projections MulEquiv (toEquiv_toFun → apply, toEquiv_invFun → symmApply, -toEquiv)
+initialize_simps_projections MulEquiv (toFun → apply, invFun → symmApply)
 
 @[to_additive (attr := simp)]
 theorem toEquiv_symm (f : M ≃* N) : f.symm.toEquiv = f.toEquiv.symm := rfl

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

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

77e63150

Diff

@@ -85,7 +85,7 @@ add_decl_doc AddEquiv.toAddHom
 structure MulEquiv (M N : Type _) [Mul M] [Mul N] extends M ≃ N, M →ₙ* N
 -- Porting note: remove when `to_additive` can do this
 -- https://github.com/leanprover-community/mathlib4/issues/660
-attribute [to_additive] MulEquiv.toMulHom
+attribute [to_additive existing] MulEquiv.toMulHom
 #align mul_equiv MulEquiv
 
 /-- The `Equiv` underlying a `MulEquiv`. -/

fix: fix simp lemmas about coercion to function (#2270)

bc10e01a

Diff

@@ -201,12 +201,16 @@ variable [Mul M] [Mul N] [Mul P] [Mul Q]
 -- Porting note: `to_fun_eq_coe` no longer needed in Lean4
 #noalign mul_equiv.to_fun_eq_coe
 #noalign add_equiv.to_fun_eq_coe
--- Porting note: `coe_to_equiv` no longer needed in Lean4
-#noalign mul_equiv.coe_to_equiv
-#noalign add_equiv.coe_to_equiv
 
 @[to_additive (attr := simp)]
-theorem coe_toMulHom {f : M ≃* N} : f.toMulHom = f.toFun := rfl
+theorem coe_toEquiv (f : M ≃* N) : (f.toEquiv : M → N) = f := rfl
+#align mul_equiv.coe_to_equiv MulEquiv.coe_toEquiv
+#align add_equiv.coe_to_equiv AddEquiv.coe_toEquiv
+
+-- porting note: todo: `MulHom.coe_mk` simplifies `↑f.toMulHom` to `f.toMulHom.toFun`,
+-- not `f.toEquiv.toFun`; use higher priority as a workaround
+@[to_additive (attr := simp 1100)]
+theorem coe_toMulHom {f : M ≃* N} : (f.toMulHom : M → N) = f := rfl
 #align mul_equiv.coe_to_mul_hom MulEquiv.coe_toMulHom
 #align add_equiv.coe_to_add_hom AddEquiv.coe_toAddHom
 
@@ -258,12 +262,18 @@ def symm {M N : Type _} [Mul M] [Mul N] (h : M ≃* N) : N ≃* M :=
 #align mul_equiv.symm MulEquiv.symm
 #align add_equiv.symm AddEquiv.symm
 
-@[to_additive (attr := simp)]
-theorem invFun_eq_symm {f : M ≃* N} : EquivLike.inv f = f.symm := rfl
+@[to_additive] -- porting note: no longer a `simp`, see below
+theorem invFun_eq_symm {f : M ≃* N} : f.invFun = f.symm := rfl
 #align mul_equiv.inv_fun_eq_symm MulEquiv.invFun_eq_symm
 -- Porting note: to_additive translated the name incorrectly in mathlib 3.
 #align add_equiv.neg_fun_eq_symm AddEquiv.invFun_eq_symm
 
+@[to_additive (attr := simp)]
+theorem coe_toEquiv_symm (f : M ≃* N) : (f.toEquiv.symm : N → M) = f.symm := rfl
+
+@[to_additive (attr := simp)]
+theorem equivLike_inv_eq_symm (f : M ≃* N) : EquivLike.inv f = f.symm := rfl
+
 -- we don't hyperlink the note in the additive version, since that breaks syntax highlighting
 -- in the whole file.
 
@@ -287,16 +297,18 @@ theorem toEquiv_symm (f : M ≃* N) : f.symm.toEquiv = f.toEquiv.symm := rfl
 #align mul_equiv.to_equiv_symm MulEquiv.toEquiv_symm
 #align add_equiv.to_equiv_symm AddEquiv.toEquiv_symm
 
--- Porting note: `coe_mk` no longer needed in Lean4
-#noalign mul_equiv.coe_mk
-#noalign add_equiv.coe_mk
+-- porting note: doesn't align with Mathlib 3 because `MulEquiv.mk` has a new signature
+@[to_additive (attr := simp)]
+theorem coe_mk (f : M ≃ N) (hf : ∀ x y, f (x * y) = f x * f y) : (mk f hf : M → N) = f := rfl
+#align mul_equiv.coe_mk MulEquiv.coe_mkₓ
+#align add_equiv.coe_mk AddEquiv.coe_mkₓ
+
 -- Porting note: `toEquiv_mk` no longer needed in Lean4
 #noalign mul_equiv.to_equiv_mk
 #noalign add_equiv.to_equiv_mk
 
 @[to_additive (attr := simp)]
-theorem symm_symm : ∀ f : M ≃* N, f.symm.symm = f
-  | ⟨_, _⟩ => rfl
+theorem symm_symm (f : M ≃* N) : f.symm.symm = f := rfl
 #align mul_equiv.symm_symm MulEquiv.symm_symm
 #align add_equiv.symm_symm AddEquiv.symm_symm
 
@@ -539,32 +551,24 @@ theorem map_ne_one_iff {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) {x :
 #align mul_equiv.map_ne_one_iff MulEquiv.map_ne_one_iff
 #align add_equiv.map_ne_zero_iff AddEquiv.map_ne_zero_iff
 
--- porting note: Mathlib 3 had `@[simps apply]` but right now in Lean 4 it's generating
--- simp lemmas which don't lint.
 /-- A bijective `Semigroup` homomorphism is an isomorphism -/
-@[to_additive "A bijective `AddSemigroup` homomorphism is an isomorphism"]
+@[to_additive (attr := simps! apply) "A bijective `AddSemigroup` homomorphism is an isomorphism"]
 noncomputable def ofBijective {M N F} [Mul M] [Mul N] [MulHomClass F M N]
 (f : F) (hf : Function.Bijective f) :
     M ≃* N :=
   { Equiv.ofBijective f hf with map_mul' := map_mul f }
 #align mul_equiv.of_bijective MulEquiv.ofBijective
 #align add_equiv.of_bijective AddEquiv.ofBijective
-
--- porting note: `@[simps apply]` should be making this lemma but it actually makes
--- a lemma with `toFun` which isn't in simp normal form.
-@[to_additive (attr := simp)] theorem ofBijective_apply {M N F} [Mul M] [Mul N] [MulHomClass F M N]
-    (f : F) (hf : Function.Bijective f) (a : M) : (MulEquiv.ofBijective f hf).toEquiv a = f a :=
-  rfl
 #align mul_equiv.of_bijective_apply MulEquiv.ofBijective_apply
 #align add_equiv.of_bijective_apply AddEquiv.ofBijective_apply
 
+-- porting note: todo: simplify `symm_apply` to `surjInv`?
 @[to_additive (attr := simp)]
 theorem ofBijective_apply_symm_apply {M N} [MulOneClass M] [MulOneClass N] {n : N} (f : M →* N)
     (hf : Function.Bijective f) : f ((Equiv.ofBijective f hf).symm n) = n :=
   (MulEquiv.ofBijective f hf).apply_symm_apply n
 #align mul_equiv.of_bijective_apply_symm_apply MulEquiv.ofBijective_apply_symm_apply
--- Porting note: No to_additive version in mathlib 3
--- #align add_equiv.of_bijective_apply_symm_apply AddEquiv.ofBijective_apply_symm_apply
+#align add_equiv.of_bijective_apply_symm_apply AddEquiv.ofBijective_apply_symm_apply
 
 /-- Extract the forward direction of a multiplicative equivalence
 as a multiplication-preserving function.
@@ -578,7 +582,7 @@ def toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) : M →* N
 
 @[to_additive (attr := simp)]
 theorem coe_toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (e : M ≃* N) :
-  ↑e.toMonoidHom = ⇑e := rfl
+  ⇑e.toMonoidHom = e := rfl
 #align mul_equiv.coe_to_monoid_hom MulEquiv.coe_toMonoidHom
 #align add_equiv.coe_to_add_monoid_hom AddEquiv.coe_toAddMonoidHom
 
@@ -610,7 +614,7 @@ def arrowCongr {M N P Q : Type _} [Mul P] [Mul Q] (f : M ≃ N) (g : P ≃* Q) :
 /-- A multiplicative analogue of `Equiv.arrowCongr`,
 for multiplicative maps from a monoid to a commutative monoid.
 -/
-@[to_additive
+@[to_additive (attr := simps apply)
   "An additive analogue of `Equiv.arrowCongr`,
   for additive maps from an additive monoid to a commutative additive monoid."]
 -- porting note: @[simps apply] removed because it was making a lemma which
@@ -625,12 +629,6 @@ def monoidHomCongr {M N P Q} [MulOneClass M] [MulOneClass N] [CommMonoid P] [Com
   map_mul' h k := by ext; simp
 #align mul_equiv.monoid_hom_congr MulEquiv.monoidHomCongr
 #align add_equiv.add_monoid_hom_congr AddEquiv.addMonoidHomCongr
-
-@[to_additive (attr := simp)] theorem monoidHomCongr_apply {M N P Q} [MulOneClass M] [MulOneClass N]
-    [CommMonoid P] [CommMonoid Q] (f : M ≃* N) (g : P ≃* Q) (h : M →* P) :
-    (MulEquiv.monoidHomCongr f g).toEquiv h = MonoidHom.comp (MulEquiv.toMonoidHom g)
-    (MonoidHom.comp h (MulEquiv.toMonoidHom (MulEquiv.symm f))) :=
-  rfl
 #align mul_equiv.monoid_hom_congr_apply MulEquiv.monoidHomCongr_apply
 #align add_equiv.add_monoid_hom_congr_apply AddEquiv.addMonoidHomCongr_apply
 
@@ -678,7 +676,7 @@ theorem piCongrRight_trans {η : Type _} {Ms Ns Ps : η → Type _} [∀ j, Mul
 
 /-- A family indexed by a nonempty subsingleton type is equivalent to the element at the single
 index. -/
-@[to_additive
+@[to_additive (attr := simps!)
   "A family indexed by a nonempty subsingleton type is
   equivalent to the element at the single index."]
 def piSubsingleton {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)] [Subsingleton ι]
@@ -686,22 +684,8 @@ def piSubsingleton {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)] [Subsing
   { Equiv.piSubsingleton M i with map_mul' := fun _ _ => Pi.mul_apply _ _ _ }
 #align mul_equiv.Pi_subsingleton MulEquiv.piSubsingleton
 #align add_equiv.Pi_subsingleton AddEquiv.piSubsingleton
-
--- porting note: the next two lemmas should be being generated by `@[to_additive, simps]`.
--- They are added manually because `@[simps]` is currently generating lemmas with `toFun` in
-@[to_additive (attr := simp)]
-theorem piSubsingleton_apply {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)]
-    [Subsingleton ι] (i : ι) (f : (x : ι) → M x) : (MulEquiv.piSubsingleton M i).toEquiv f = f i :=
-  rfl
 #align mul_equiv.Pi_subsingleton_apply MulEquiv.piSubsingleton_apply
 #align add_equiv.Pi_subsingleton_apply AddEquiv.piSubsingleton_apply
-
-@[to_additive (attr := simp)]
-theorem piSubsingleton_symmApply {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)]
-    [Subsingleton ι] (i : ι) (x : M i) (b : ι) :
-    (MulEquiv.symm (MulEquiv.piSubsingleton M i)) x b =
-    cast (Subsingleton.elim i b ▸ rfl : M i = M b) x :=
-rfl
 #align mul_equiv.Pi_subsingleton_symm_apply MulEquiv.piSubsingleton_symmApply
 #align add_equiv.Pi_subsingleton_symm_apply AddEquiv.piSubsingleton_symmApply
 
@@ -755,7 +739,7 @@ def MulHom.toMulEquiv [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M) (h₁
 @[to_additive (attr := simp)]
 theorem MulHom.toMulEquiv_apply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M)
     (h₁ : g.comp f = MulHom.id _) (h₂ : f.comp g = MulHom.id _) :
-    ((MulHom.toMulEquiv f g h₁ h₂).toEquiv : M → N) = f :=
+    ((MulHom.toMulEquiv f g h₁ h₂) : M → N) = f :=
   rfl
 #align mul_hom.to_mul_equiv_apply MulHom.toMulEquiv_apply
 #align add_hom.to_add_equiv_apply AddHom.toAddEquiv_apply
@@ -768,12 +752,10 @@ theorem MulHom.toMulEquiv_symmApply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →
 #align mul_hom.to_mul_equiv_symm_apply MulHom.toMulEquiv_symmApply
 #align add_hom.to_add_equiv_symm_apply AddHom.toAddEquiv_symmApply
 
--- porting note: `@[simps (config := { fullyApplied := false })]` generates a simp lemma
--- which is not in simp normal form, so we add them manually
 /-- Given a pair of monoid homomorphisms `f`, `g` such that `g.comp f = id` and `f.comp g = id`,
 returns an multiplicative equivalence with `toFun = f` and `invFun = g`.  This constructor is
 useful if the underlying type(s) have specialized `ext` lemmas for monoid homomorphisms. -/
-@[to_additive
+@[to_additive (attr := simps (config := { fullyApplied := false }))
   "Given a pair of additive monoid homomorphisms `f`, `g` such that `g.comp f = id`
   and `f.comp g = id`, returns an additive equivalence with `toFun = f` and `invFun = g`.  This
   constructor is useful if the underlying type(s) have specialized `ext` lemmas for additive
@@ -787,23 +769,8 @@ def MonoidHom.toMulEquiv [MulOneClass M] [MulOneClass N] (f : M →* N) (g : N 
   map_mul' := f.map_mul
 #align monoid_hom.to_mul_equiv MonoidHom.toMulEquiv
 #align add_monoid_hom.to_add_equiv AddMonoidHom.toAddEquiv
-
--- porting note: the next 2 lemmas should be being generated by
--- `@[to_additive, simps (config := { fullyApplied := false })]`
--- but right now it's generating `simp` lemmas which aren't in `simp` normal form.
-@[to_additive (attr := simp)]
-theorem MonoidHom.toMulEquiv_apply [MulOneClass M] [MulOneClass N] (f : M →* N)
-    (g : N →* M) (h₁ : g.comp f = MonoidHom.id _) (h₂ : f.comp g = MonoidHom.id _) :
-    ((MonoidHom.toMulEquiv f g h₁ h₂).toEquiv : M → N) = ↑f :=
-  rfl
 #align monoid_hom.to_mul_equiv_apply MonoidHom.toMulEquiv_apply
 #align add_monoid_hom.to_add_equiv_apply AddMonoidHom.toAddEquiv_apply
-
-@[to_additive (attr := simp)]
-theorem MonoidHom.toMulEquiv_symmApply [MulOneClass M] [MulOneClass N]
-    (f : M →* N) (g : N →* M) (h₁ : g.comp f = MonoidHom.id _) (h₂ : f.comp g = MonoidHom.id _) :
-    (MulEquiv.symm (MonoidHom.toMulEquiv f g h₁ h₂) : N → M) = g :=
-  rfl
 #align monoid_hom.to_mul_equiv_symm_apply MonoidHom.toMulEquiv_symmApply
 #align add_monoid_hom.to_add_equiv_symm_apply AddMonoidHom.toAddEquiv_symmApply

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

@@ -814,7 +814,7 @@ section InvolutiveInv
 variable (G) [InvolutiveInv G]
 
 /-- Inversion on a `Group` or `GroupWithZero` is a permutation of the underlying type. -/
-@[to_additive (attr := simps (config := { fullyApplied := false }) apply)
+@[to_additive (attr := simps! (config := { fullyApplied := false }) apply)
     "Negation on an `AddGroup` is a permutation of the underlying type."]
 protected def inv : Perm G :=
   inv_involutive.toPerm _

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

adaaf293

Diff

@@ -51,13 +51,14 @@ def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M) (h₁ : Funct
 #align add_hom.inverse AddHom.inverse
 
 /-- The inverse of a bijective `MonoidHom` is a `MonoidHom`. -/
-@[to_additive "The inverse of a bijective `AddMonoidHom` is an `AddMonoidHom`.", simps]
+@[to_additive (attr := simps) "The inverse of a bijective `AddMonoidHom` is an `AddMonoidHom`."]
 def MonoidHom.inverse {A B : Type _} [Monoid A] [Monoid B] (f : A →* B) (g : B → A)
   (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) : B →* A :=
   { (f : A →ₙ* B).inverse g h₁ h₂ with toFun := g, map_one' := by rw [← f.map_one, h₁] }
 #align monoid_hom.inverse MonoidHom.inverse
 #align add_monoid_hom.inverse AddMonoidHom.inverse
 #align monoid_hom.inverse_apply MonoidHom.inverse_apply
+#align add_monoid_hom.inverse_apply AddMonoidHom.inverse_apply
 
 /-- `AddEquiv α β` is the type of an equiv `α ≃ β` which preserves addition. -/
 structure AddEquiv (A B : Type _) [Add A] [Add B] extends A ≃ B, AddHom A B
@@ -592,9 +593,8 @@ theorem toMonoidHom_injective {M N} [MulOneClass M] [MulOneClass N] :
 /-- A multiplicative analogue of `Equiv.arrowCongr`,
 where the equivalence between the targets is multiplicative.
 -/
-@[to_additive "An additive analogue of `Equiv.arrowCongr`,
-  where the equivalence between the targets is additive.",
-  simps apply]
+@[to_additive (attr := simps apply) "An additive analogue of `Equiv.arrowCongr`,
+  where the equivalence between the targets is additive."]
 def arrowCongr {M N P Q : Type _} [Mul P] [Mul Q] (f : M ≃ N) (g : P ≃* Q) :
   (M → P) ≃* (N → Q) where
   toFun h n := g (h (f.symm n))
@@ -605,6 +605,7 @@ def arrowCongr {M N P Q : Type _} [Mul P] [Mul Q] (f : M ≃ N) (g : P ≃* Q) :
 #align mul_equiv.arrow_congr MulEquiv.arrowCongr
 #align add_equiv.arrow_congr AddEquiv.arrowCongr
 #align mul_equiv.arrow_congr_apply MulEquiv.arrowCongr_apply
+#align add_equiv.arrow_congr_apply AddEquiv.arrowCongr_apply
 
 /-- A multiplicative analogue of `Equiv.arrowCongr`,
 for multiplicative maps from a monoid to a commutative monoid.
@@ -639,13 +640,12 @@ multiplicative equivalence between `Π j, Ms j` and `Π j, Ns j`.
 This is the `MulEquiv` version of `Equiv.piCongrRight`, and the dependent version of
 `MulEquiv.arrowCongr`.
 -/
-@[to_additive
+@[to_additive (attr := simps apply)
   "A family of additive equivalences `Π j, (Ms j ≃+ Ns j)`
   generates an additive equivalence between `Π j, Ms j` and `Π j, Ns j`.
 
   This is the `AddEquiv` version of `Equiv.piCongrRight`, and the dependent version of
-  `AddEquiv.arrowCongr`.",
-  simps apply]
+  `AddEquiv.arrowCongr`."]
 def piCongrRight {η : Type _} {Ms Ns : η → Type _} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
   (es : ∀ j, Ms j ≃* Ns j) : (∀ j, Ms j) ≃* ∀ j, Ns j :=
   { Equiv.piCongrRight fun j => (es j).toEquiv with
@@ -655,6 +655,7 @@ def piCongrRight {η : Type _} {Ms Ns : η → Type _} [∀ j, Mul (Ms j)] [∀
 #align mul_equiv.Pi_congr_right MulEquiv.piCongrRight
 #align add_equiv.Pi_congr_right AddEquiv.piCongrRight
 #align mul_equiv.Pi_congr_right_apply MulEquiv.piCongrRight_apply
+#align add_equiv.Pi_congr_right_apply AddEquiv.piCongrRight_apply
 
 @[to_additive (attr := simp)]
 theorem piCongrRight_refl {η : Type _} {Ms : η → Type _} [∀ j, Mul (Ms j)] :

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

@@ -57,6 +57,7 @@ def MonoidHom.inverse {A B : Type _} [Monoid A] [Monoid B] (f : A →* B) (g : B
   { (f : A →ₙ* B).inverse g h₁ h₂ with toFun := g, map_one' := by rw [← f.map_one, h₁] }
 #align monoid_hom.inverse MonoidHom.inverse
 #align add_monoid_hom.inverse AddMonoidHom.inverse
+#align monoid_hom.inverse_apply MonoidHom.inverse_apply
 
 /-- `AddEquiv α β` is the type of an equiv `α ≃ β` which preserves addition. -/
 structure AddEquiv (A B : Type _) [Add A] [Add B] extends A ≃ B, AddHom A B
@@ -72,9 +73,11 @@ class AddEquivClass (F : Type _) (A B : outParam (Type _)) [Add A] [Add B]
 
 /-- The `Equiv` underlying an `AddEquiv`. -/
 add_decl_doc AddEquiv.toEquiv
+#align add_equiv.to_equiv AddEquiv.toEquiv
 
 /-- The `AddHom` underlying a `AddEquiv`. -/
 add_decl_doc AddEquiv.toAddHom
+#align add_equiv.to_add_hom AddEquiv.toAddHom
 
 /-- `MulEquiv α β` is the type of an equiv `α ≃ β` which preserves multiplication. -/
 @[to_additive]
@@ -86,9 +89,11 @@ attribute [to_additive] MulEquiv.toMulHom
 
 /-- The `Equiv` underlying a `MulEquiv`. -/
 add_decl_doc MulEquiv.toEquiv
+#align mul_equiv.to_equiv MulEquiv.toEquiv
 
 /-- The `MulHom` underlying a `MulEquiv`. -/
 add_decl_doc MulEquiv.toMulHom
+#align mul_equiv.to_mul_hom MulEquiv.toMulHom
 
 /-- `MulEquivClass F A B` states that `F` is a type of multiplication-preserving morphisms.
 You should extend this class when you extend `MulEquiv`. -/
@@ -599,6 +604,7 @@ def arrowCongr {M N P Q : Type _} [Mul P] [Mul Q] (f : M ≃ N) (g : P ≃* Q) :
   map_mul' h k := by ext; simp
 #align mul_equiv.arrow_congr MulEquiv.arrowCongr
 #align add_equiv.arrow_congr AddEquiv.arrowCongr
+#align mul_equiv.arrow_congr_apply MulEquiv.arrowCongr_apply
 
 /-- A multiplicative analogue of `Equiv.arrowCongr`,
 for multiplicative maps from a monoid to a commutative monoid.
@@ -648,6 +654,7 @@ def piCongrRight {η : Type _} {Ms Ns : η → Type _} [∀ j, Mul (Ms j)] [∀
     map_mul' := fun x y => funext fun j => (es j).map_mul (x j) (y j) }
 #align mul_equiv.Pi_congr_right MulEquiv.piCongrRight
 #align add_equiv.Pi_congr_right AddEquiv.piCongrRight
+#align mul_equiv.Pi_congr_right_apply MulEquiv.piCongrRight_apply
 
 @[to_additive (attr := simp)]
 theorem piCongrRight_refl {η : Type _} {Ms : η → Type _} [∀ j, Mul (Ms j)] :

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

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

ed378238

Diff

@@ -202,6 +202,7 @@ variable [Mul M] [Mul N] [Mul P] [Mul Q]
 @[to_additive (attr := simp)]
 theorem coe_toMulHom {f : M ≃* N} : f.toMulHom = f.toFun := rfl
 #align mul_equiv.coe_to_mul_hom MulEquiv.coe_toMulHom
+#align add_equiv.coe_to_add_hom AddEquiv.coe_toAddHom
 
 /-- A multiplicative isomorphism preserves multiplication. -/
 @[to_additive "An additive isomorphism preserves addition."]

chore: fix most phantom #aligns (#1794)

3d3fb046

Diff

@@ -254,7 +254,8 @@ def symm {M N : Type _} [Mul M] [Mul N] (h : M ≃* N) : N ≃* M :=
 @[to_additive (attr := simp)]
 theorem invFun_eq_symm {f : M ≃* N} : EquivLike.inv f = f.symm := rfl
 #align mul_equiv.inv_fun_eq_symm MulEquiv.invFun_eq_symm
-#align add_equiv.inv_fun_eq_symm AddEquiv.invFun_eq_symm
+-- Porting note: to_additive translated the name incorrectly in mathlib 3.
+#align add_equiv.neg_fun_eq_symm AddEquiv.invFun_eq_symm
 
 -- we don't hyperlink the note in the additive version, since that breaks syntax highlighting
 -- in the whole file.
@@ -555,7 +556,8 @@ theorem ofBijective_apply_symm_apply {M N} [MulOneClass M] [MulOneClass N] {n :
     (hf : Function.Bijective f) : f ((Equiv.ofBijective f hf).symm n) = n :=
   (MulEquiv.ofBijective f hf).apply_symm_apply n
 #align mul_equiv.of_bijective_apply_symm_apply MulEquiv.ofBijective_apply_symm_apply
-#align add_equiv.of_bijective_apply_symm_apply AddEquiv.ofBijective_apply_symm_apply
+-- Porting note: No to_additive version in mathlib 3
+-- #align add_equiv.of_bijective_apply_symm_apply AddEquiv.ofBijective_apply_symm_apply
 
 /-- Extract the forward direction of a multiplicative equivalence
 as a multiplication-preserving function.
@@ -691,8 +693,8 @@ theorem piSubsingleton_symmApply {ι : Type _} (M : ι → Type _) [∀ j, Mul (
     (MulEquiv.symm (MulEquiv.piSubsingleton M i)) x b =
     cast (Subsingleton.elim i b ▸ rfl : M i = M b) x :=
 rfl
-#align mul_equiv.Pi_subsingleton_symmApply MulEquiv.piSubsingleton_symmApply
-#align add_equiv.Pi_subsingleton_symmApply AddEquiv.piSubsingleton_symmApply
+#align mul_equiv.Pi_subsingleton_symm_apply MulEquiv.piSubsingleton_symmApply
+#align add_equiv.Pi_subsingleton_symm_apply AddEquiv.piSubsingleton_symmApply
 
 /-!
 # Groups
@@ -775,7 +777,7 @@ def MonoidHom.toMulEquiv [MulOneClass M] [MulOneClass N] (f : M →* N) (g : N 
   right_inv := FunLike.congr_fun h₂
   map_mul' := f.map_mul
 #align monoid_hom.to_mul_equiv MonoidHom.toMulEquiv
-#align add_monoid_hom.to_add_mul_equiv AddMonoidHom.toAddEquiv
+#align add_monoid_hom.to_add_equiv AddMonoidHom.toAddEquiv
 
 -- porting note: the next 2 lemmas should be being generated by
 -- `@[to_additive, simps (config := { fullyApplied := false })]`

feat: port Algebra.Order.Archimedean (#1462)

Co-authored-by: ADedecker <anatolededecker@gmail.com> Co-authored-by: Heather Macbeth <25316162+hrmacbeth@users.noreply.github.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com>

daa535fc

Diff

@@ -803,12 +803,14 @@ section InvolutiveInv
 variable (G) [InvolutiveInv G]
 
 /-- Inversion on a `Group` or `GroupWithZero` is a permutation of the underlying type. -/
-@[to_additive "Negation on an `AddGroup` is a permutation of the underlying type.",
-  simps (config := { fullyApplied := false }) apply]
+@[to_additive (attr := simps (config := { fullyApplied := false }) apply)
+    "Negation on an `AddGroup` is a permutation of the underlying type."]
 protected def inv : Perm G :=
   inv_involutive.toPerm _
 #align equiv.inv Equiv.inv
 #align equiv.neg Equiv.neg
+#align equiv.inv_apply Equiv.inv_apply
+#align equiv.neg_apply Equiv.neg_apply
 
 variable {G}

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

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

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

56bf4cd6

Diff

@@ -143,7 +143,7 @@ instance (priority := 100) toMonoidWithZeroHomClass
 
 variable {F}
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem map_eq_one_iff {M N} [MulOneClass M] [MulOneClass N] [MulEquivClass F M N] (h : F) {x : M} :
   h x = 1 ↔ x = 1 := _root_.map_eq_one_iff h (EquivLike.injective h)
 #align mul_equiv_class.map_eq_one_iff MulEquivClass.map_eq_one_iff
@@ -159,7 +159,8 @@ end MulEquivClass
 
 /-- Turn an element of a type `F` satisfying `MulEquivClass F α β` into an actual
 `MulEquiv`. This is declared as the default coercion from `F` to `α ≃* β`. -/
-@[coe, to_additive "Turn an element of a type `F` satisfying `AddEquivClass F α β` into an actual
+@[to_additive (attr := coe)
+"Turn an element of a type `F` satisfying `AddEquivClass F α β` into an actual
 `AddEquiv`. This is declared as the default coercion from `F` to `α ≃+ β`."]
 def MulEquivClass.toMulEquiv [Mul α] [Mul β] [MulEquivClass F α β] (f : F) : α ≃* β :=
 { (f : α ≃ β), (f : α →ₙ* β) with }
@@ -198,7 +199,7 @@ variable [Mul M] [Mul N] [Mul P] [Mul Q]
 #noalign mul_equiv.coe_to_equiv
 #noalign add_equiv.coe_to_equiv
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem coe_toMulHom {f : M ≃* N} : f.toMulHom = f.toFun := rfl
 #align mul_equiv.coe_to_mul_hom MulEquiv.coe_toMulHom
 
@@ -234,7 +235,7 @@ protected theorem surjective (e : M ≃* N) : Function.Surjective e :=
 #align add_equiv.surjective AddEquiv.surjective
 
 /-- The identity map is a multiplicative isomorphism. -/
-@[refl, to_additive "The identity map is an additive isomorphism."]
+@[to_additive (attr := refl) "The identity map is an additive isomorphism."]
 def refl (M : Type _) [Mul M] : M ≃* M :=
   { Equiv.refl _ with map_mul' := fun _ _ => rfl }
 #align mul_equiv.refl MulEquiv.refl
@@ -244,13 +245,13 @@ def refl (M : Type _) [Mul M] : M ≃* M :=
 instance : Inhabited (M ≃* M) := ⟨refl M⟩
 
 /-- The inverse of an isomorphism is an isomorphism. -/
-@[symm, to_additive "The inverse of an isomorphism is an isomorphism."]
+@[to_additive (attr := symm) "The inverse of an isomorphism is an isomorphism."]
 def symm {M N : Type _} [Mul M] [Mul N] (h : M ≃* N) : N ≃* M :=
   ⟨h.toEquiv.symm, (h.toMulHom.inverse h.toEquiv.symm h.left_inv h.right_inv).map_mul⟩
 #align mul_equiv.symm MulEquiv.symm
 #align add_equiv.symm AddEquiv.symm
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem invFun_eq_symm {f : M ≃* N} : EquivLike.inv f = f.symm := rfl
 #align mul_equiv.inv_fun_eq_symm MulEquiv.invFun_eq_symm
 #align add_equiv.inv_fun_eq_symm AddEquiv.invFun_eq_symm
@@ -273,7 +274,7 @@ initialize_simps_projections AddEquiv (toEquiv_toFun → apply, toEquiv_invFun 
 
 initialize_simps_projections MulEquiv (toEquiv_toFun → apply, toEquiv_invFun → symmApply, -toEquiv)
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem toEquiv_symm (f : M ≃* N) : f.symm.toEquiv = f.toEquiv.symm := rfl
 #align mul_equiv.to_equiv_symm MulEquiv.toEquiv_symm
 #align add_equiv.to_equiv_symm AddEquiv.toEquiv_symm
@@ -285,7 +286,7 @@ theorem toEquiv_symm (f : M ≃* N) : f.symm.toEquiv = f.toEquiv.symm := rfl
 #noalign mul_equiv.to_equiv_mk
 #noalign add_equiv.to_equiv_mk
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem symm_symm : ∀ f : M ≃* N, f.symm.symm = f
   | ⟨_, _⟩ => rfl
 #align mul_equiv.symm_symm MulEquiv.symm_symm
@@ -299,19 +300,19 @@ theorem symm_bijective : Function.Bijective (symm : M ≃* N → N ≃* M) :=
 
 -- Porting note: this doesn't really align with mathlib3's `symm_mk`,
 -- because the signature of `MulEquiv.mk` has changed.
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem symm_mk (f : M ≃ N) (h) :
   (MulEquiv.mk f h).symm = ⟨f.symm, (MulEquiv.mk f h).symm.map_mul'⟩ := rfl
 #align mul_equiv.symm_mk MulEquiv.symm_mkₓ
 #align add_equiv.symm_mk AddEquiv.symm_mkₓ
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem refl_symm : (refl M).symm = refl M := rfl
 #align mul_equiv.refl_symm MulEquiv.refl_symm
 #align add_equiv.refl_symm AddEquiv.refl_symm
 
 /-- Transitivity of multiplication-preserving isomorphisms -/
-@[trans, to_additive "Transitivity of addition-preserving isomorphisms"]
+@[to_additive (attr := trans) "Transitivity of addition-preserving isomorphisms"]
 def trans (h1 : M ≃* N) (h2 : N ≃* P) : M ≃* P :=
   { h1.toEquiv.trans h2.toEquiv with
     map_mul' := fun x y => show h2 (h1 (x * y)) = h2 (h1 x) * h2 (h1 y) by
@@ -320,52 +321,52 @@ def trans (h1 : M ≃* N) (h2 : N ≃* P) : M ≃* P :=
 #align add_equiv.trans AddEquiv.trans
 
 /-- `e.symm` is a right inverse of `e`, written as `e (e.symm y) = y`. -/
-@[simp, to_additive "`e.symm` is a right inverse of `e`, written as `e (e.symm y) = y`."]
+@[to_additive (attr := simp) "`e.symm` is a right inverse of `e`, written as `e (e.symm y) = y`."]
 theorem apply_symm_apply (e : M ≃* N) (y : N) : e (e.symm y) = y :=
   e.toEquiv.apply_symm_apply y
 #align mul_equiv.apply_symm_apply MulEquiv.apply_symm_apply
 #align add_equiv.apply_symm_apply AddEquiv.apply_symm_apply
 
 /-- `e.symm` is a left inverse of `e`, written as `e.symm (e y) = y`. -/
-@[simp, to_additive "`e.symm` is a left inverse of `e`, written as `e.symm (e y) = y`."]
+@[to_additive (attr := simp) "`e.symm` is a left inverse of `e`, written as `e.symm (e y) = y`."]
 theorem symm_apply_apply (e : M ≃* N) (x : M) : e.symm (e x) = x :=
   e.toEquiv.symm_apply_apply x
 #align mul_equiv.symm_apply_apply MulEquiv.symm_apply_apply
 #align add_equiv.symm_apply_apply AddEquiv.symm_apply_apply
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem symm_comp_self (e : M ≃* N) : e.symm ∘ e = id :=
   funext e.symm_apply_apply
 #align mul_equiv.symm_comp_self MulEquiv.symm_comp_self
 #align add_equiv.symm_comp_self AddEquiv.symm_comp_self
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem self_comp_symm (e : M ≃* N) : e ∘ e.symm = id :=
   funext e.apply_symm_apply
 #align mul_equiv.self_comp_symm MulEquiv.self_comp_symm
 #align add_equiv.self_comp_symm AddEquiv.self_comp_symm
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem coe_refl : ↑(refl M) = id := rfl
 #align mul_equiv.coe_refl MulEquiv.coe_refl
 #align add_equiv.coe_refl AddEquiv.coe_refl
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem refl_apply (m : M) : refl M m = m := rfl
 #align mul_equiv.refl_apply MulEquiv.refl_apply
 #align add_equiv.refl_apply AddEquiv.refl_apply
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem coe_trans (e₁ : M ≃* N) (e₂ : N ≃* P) : ↑(e₁.trans e₂) = e₂ ∘ e₁ := rfl
 #align mul_equiv.coe_trans MulEquiv.coe_trans
 #align add_equiv.coe_trans AddEquiv.coe_trans
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem trans_apply (e₁ : M ≃* N) (e₂ : N ≃* P) (m : M) : e₁.trans e₂ m = e₂ (e₁ m) := rfl
 #align mul_equiv.trans_apply MulEquiv.trans_apply
 #align add_equiv.trans_apply AddEquiv.trans_apply
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem symm_trans_apply (e₁ : M ≃* N) (e₂ : N ≃* P) (p : P) :
   (e₁.trans e₂).symm p = e₁.symm (e₂.symm p) := rfl
 #align mul_equiv.symm_trans_apply MulEquiv.symm_trans_apply
@@ -424,13 +425,13 @@ theorem symm_comp_eq {α : Type _} (e : M ≃* N) (f : α → M) (g : α → N)
 #align mul_equiv.symm_comp_eq MulEquiv.symm_comp_eq
 #align add_equiv.symm_comp_eq AddEquiv.symm_comp_eq
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem symm_trans_self (e : M ≃* N) : e.symm.trans e = refl N :=
   FunLike.ext _ _ e.apply_symm_apply
 #align mul_equiv.symm_trans_self MulEquiv.symm_trans_self
 #align add_equiv.symm_trans_self AddEquiv.symm_trans_self
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem self_trans_symm (e : M ≃* N) : e.trans e.symm = refl M :=
   FunLike.ext _ _ e.symm_apply_apply
 #align mul_equiv.self_trans_symm MulEquiv.self_trans_symm
@@ -452,7 +453,7 @@ theorem coe_monoidHom_trans {M N P} [MulOneClass M] [MulOneClass N] [MulOneClass
 
 /-- Two multiplicative isomorphisms agree if they are defined by the
 same underlying function. -/
-@[ext, to_additive
+@[to_additive (attr := ext)
   "Two additive isomorphisms agree if they are defined by the same underlying function."]
 theorem ext {f g : MulEquiv M N} (h : ∀ x, f x = g x) : f = g :=
   FunLike.ext f g h
@@ -465,13 +466,13 @@ theorem ext_iff {f g : MulEquiv M N} : f = g ↔ ∀ x, f x = g x :=
 #align mul_equiv.ext_iff MulEquiv.ext_iff
 #align add_equiv.ext_iff AddEquiv.ext_iff
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mk_coe (e : M ≃* N) (e' h₁ h₂ h₃) : (⟨⟨e, e', h₁, h₂⟩, h₃⟩ : M ≃* N) = e :=
   ext fun _ => rfl
 #align mul_equiv.mk_coe MulEquiv.mk_coe
 #align add_equiv.mk_coe AddEquiv.mk_coe
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mk_coe' (e : M ≃* N) (f h₁ h₂ h₃) : (MulEquiv.mk ⟨f, e, h₁, h₂⟩ h₃ : N ≃* M) = e.symm :=
   symm_bijective.injective <| ext fun _ => rfl
 #align mul_equiv.mk_coe' MulEquiv.mk_coe'
@@ -543,13 +544,13 @@ noncomputable def ofBijective {M N F} [Mul M] [Mul N] [MulHomClass F M N]
 
 -- porting note: `@[simps apply]` should be making this lemma but it actually makes
 -- a lemma with `toFun` which isn't in simp normal form.
-@[simp, to_additive] theorem ofBijective_apply {M N F} [Mul M] [Mul N] [MulHomClass F M N]
+@[to_additive (attr := simp)] theorem ofBijective_apply {M N F} [Mul M] [Mul N] [MulHomClass F M N]
     (f : F) (hf : Function.Bijective f) (a : M) : (MulEquiv.ofBijective f hf).toEquiv a = f a :=
   rfl
 #align mul_equiv.of_bijective_apply MulEquiv.ofBijective_apply
 #align add_equiv.of_bijective_apply AddEquiv.ofBijective_apply
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem ofBijective_apply_symm_apply {M N} [MulOneClass M] [MulOneClass N] {n : N} (f : M →* N)
     (hf : Function.Bijective f) : f ((Equiv.ofBijective f hf).symm n) = n :=
   (MulEquiv.ofBijective f hf).apply_symm_apply n
@@ -566,7 +567,7 @@ def toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) : M →* N
 #align mul_equiv.to_monoid_hom MulEquiv.toMonoidHom
 #align add_equiv.to_add_monoid_hom AddEquiv.toAddMonoidHom
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem coe_toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (e : M ≃* N) :
   ↑e.toMonoidHom = ⇑e := rfl
 #align mul_equiv.coe_to_monoid_hom MulEquiv.coe_toMonoidHom
@@ -615,7 +616,7 @@ def monoidHomCongr {M N P Q} [MulOneClass M] [MulOneClass N] [CommMonoid P] [Com
 #align mul_equiv.monoid_hom_congr MulEquiv.monoidHomCongr
 #align add_equiv.add_monoid_hom_congr AddEquiv.addMonoidHomCongr
 
-@[simp, to_additive] theorem monoidHomCongr_apply {M N P Q} [MulOneClass M] [MulOneClass N]
+@[to_additive (attr := simp)] theorem monoidHomCongr_apply {M N P Q} [MulOneClass M] [MulOneClass N]
     [CommMonoid P] [CommMonoid Q] (f : M ≃* N) (g : P ≃* Q) (h : M →* P) :
     (MulEquiv.monoidHomCongr f g).toEquiv h = MonoidHom.comp (MulEquiv.toMonoidHom g)
     (MonoidHom.comp h (MulEquiv.toMonoidHom (MulEquiv.symm f))) :=
@@ -645,19 +646,19 @@ def piCongrRight {η : Type _} {Ms Ns : η → Type _} [∀ j, Mul (Ms j)] [∀
 #align mul_equiv.Pi_congr_right MulEquiv.piCongrRight
 #align add_equiv.Pi_congr_right AddEquiv.piCongrRight
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem piCongrRight_refl {η : Type _} {Ms : η → Type _} [∀ j, Mul (Ms j)] :
   (piCongrRight fun j => MulEquiv.refl (Ms j)) = MulEquiv.refl _ := rfl
 #align mul_equiv.Pi_congr_right_refl MulEquiv.piCongrRight_refl
 #align add_equiv.Pi_congr_right_refl AddEquiv.piCongrRight_refl
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem piCongrRight_symm {η : Type _} {Ms Ns : η → Type _} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
   (es : ∀ j, Ms j ≃* Ns j) : (piCongrRight es).symm = piCongrRight fun i => (es i).symm := rfl
 #align mul_equiv.Pi_congr_right_symm MulEquiv.piCongrRight_symm
 #align add_equiv.Pi_congr_right_symm AddEquiv.piCongrRight_symm
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem piCongrRight_trans {η : Type _} {Ms Ns Ps : η → Type _} [∀ j, Mul (Ms j)]
   [∀ j, Mul (Ns j)] [∀ j, Mul (Ps j)] (es : ∀ j, Ms j ≃* Ns j) (fs : ∀ j, Ns j ≃* Ps j) :
   (piCongrRight es).trans (piCongrRight fs) = piCongrRight fun i => (es i).trans (fs i) := rfl
@@ -677,13 +678,15 @@ def piSubsingleton {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)] [Subsing
 
 -- porting note: the next two lemmas should be being generated by `@[to_additive, simps]`.
 -- They are added manually because `@[simps]` is currently generating lemmas with `toFun` in
-@[simp, to_additive] theorem piSubsingleton_apply {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)]
+@[to_additive (attr := simp)]
+theorem piSubsingleton_apply {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)]
     [Subsingleton ι] (i : ι) (f : (x : ι) → M x) : (MulEquiv.piSubsingleton M i).toEquiv f = f i :=
   rfl
 #align mul_equiv.Pi_subsingleton_apply MulEquiv.piSubsingleton_apply
 #align add_equiv.Pi_subsingleton_apply AddEquiv.piSubsingleton_apply
 
-@[simp, to_additive] theorem piSubsingleton_symmApply {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)]
+@[to_additive (attr := simp)]
+theorem piSubsingleton_symmApply {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)]
     [Subsingleton ι] (i : ι) (x : M i) (b : ι) :
     (MulEquiv.symm (MulEquiv.piSubsingleton M i)) x b =
     cast (Subsingleton.elim i b ▸ rfl : M i = M b) x :=
@@ -738,14 +741,16 @@ def MulHom.toMulEquiv [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M) (h₁
 
 -- porting note: the next two lemmas were added manually because `@[simps]` is generating
 -- lemmas with `toFun` in
-@[simp, to_additive] theorem MulHom.toMulEquiv_apply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M)
+@[to_additive (attr := simp)]
+theorem MulHom.toMulEquiv_apply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M)
     (h₁ : g.comp f = MulHom.id _) (h₂ : f.comp g = MulHom.id _) :
     ((MulHom.toMulEquiv f g h₁ h₂).toEquiv : M → N) = f :=
   rfl
 #align mul_hom.to_mul_equiv_apply MulHom.toMulEquiv_apply
 #align add_hom.to_add_equiv_apply AddHom.toAddEquiv_apply
 
-@[simp, to_additive] theorem MulHom.toMulEquiv_symmApply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M)
+@[to_additive (attr := simp)]
+theorem MulHom.toMulEquiv_symmApply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M)
     (h₁ : g.comp f = MulHom.id _) (h₂ : f.comp g = MulHom.id _) :
     (MulEquiv.symm (MulHom.toMulEquiv f g h₁ h₂) : N → M) = ↑g :=
   rfl
@@ -775,14 +780,16 @@ def MonoidHom.toMulEquiv [MulOneClass M] [MulOneClass N] (f : M →* N) (g : N 
 -- porting note: the next 2 lemmas should be being generated by
 -- `@[to_additive, simps (config := { fullyApplied := false })]`
 -- but right now it's generating `simp` lemmas which aren't in `simp` normal form.
-@[simp, to_additive] theorem MonoidHom.toMulEquiv_apply [MulOneClass M] [MulOneClass N] (f : M →* N)
+@[to_additive (attr := simp)]
+theorem MonoidHom.toMulEquiv_apply [MulOneClass M] [MulOneClass N] (f : M →* N)
     (g : N →* M) (h₁ : g.comp f = MonoidHom.id _) (h₂ : f.comp g = MonoidHom.id _) :
     ((MonoidHom.toMulEquiv f g h₁ h₂).toEquiv : M → N) = ↑f :=
   rfl
 #align monoid_hom.to_mul_equiv_apply MonoidHom.toMulEquiv_apply
 #align add_monoid_hom.to_add_equiv_apply AddMonoidHom.toAddEquiv_apply
 
-@[simp, to_additive] theorem MonoidHom.toMulEquiv_symmApply [MulOneClass M] [MulOneClass N]
+@[to_additive (attr := simp)]
+theorem MonoidHom.toMulEquiv_symmApply [MulOneClass M] [MulOneClass N]
     (f : M →* N) (g : N →* M) (h₁ : g.comp f = MonoidHom.id _) (h₂ : f.comp g = MonoidHom.id _) :
     (MulEquiv.symm (MonoidHom.toMulEquiv f g h₁ h₂) : N → M) = g :=
   rfl
@@ -805,7 +812,7 @@ protected def inv : Perm G :=
 
 variable {G}
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem inv_symm : (Equiv.inv G).symm = Equiv.inv G := rfl
 #align equiv.inv_symm Equiv.inv_symm
 #align equiv.neg_symm Equiv.neg_symm

chore: deal with some old porting notes (#1405)

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

1a8e98c7

Diff

@@ -188,13 +188,13 @@ instance [Mul M] [Mul N] : MulEquivClass (M ≃* N) M N where
 
 variable [Mul M] [Mul N] [Mul P] [Mul Q]
 
--- Porting note: `toEquiv_eq_coe` no longer needed in Lean4
+-- Porting note: `to_equiv_eq_coe` no longer needed in Lean4
 #noalign mul_equiv.to_equiv_eq_coe
 #noalign add_equiv.to_equiv_eq_coe
--- Porting note: `toFun_eq_coe` no longer needed in Lean4
+-- Porting note: `to_fun_eq_coe` no longer needed in Lean4
 #noalign mul_equiv.to_fun_eq_coe
 #noalign add_equiv.to_fun_eq_coe
--- Porting note: `coe_toEquiv` no longer needed in Lean4
+-- Porting note: `coe_to_equiv` no longer needed in Lean4
 #noalign mul_equiv.coe_to_equiv
 #noalign add_equiv.coe_to_equiv
 
@@ -250,7 +250,7 @@ def symm {M N : Type _} [Mul M] [Mul N] (h : M ≃* N) : N ≃* M :=
 #align mul_equiv.symm MulEquiv.symm
 #align add_equiv.symm AddEquiv.symm
 
-@[simp, to_additive AddEquiv.invFun_eq_symm]
+@[simp, to_additive]
 theorem invFun_eq_symm {f : M ≃* N} : EquivLike.inv f = f.symm := rfl
 #align mul_equiv.inv_fun_eq_symm MulEquiv.invFun_eq_symm
 #align add_equiv.inv_fun_eq_symm AddEquiv.invFun_eq_symm
@@ -459,10 +459,6 @@ theorem ext {f g : MulEquiv M N} (h : ∀ x, f x = g x) : f = g :=
 #align mul_equiv.ext MulEquiv.ext
 #align add_equiv.ext AddEquiv.ext
 
--- Porting note: can be removed after https://github.com/leanprover-community/mathlib4/pull/954
--- is merged.
-attribute [ext] AddEquiv.ext
-
 @[to_additive]
 theorem ext_iff {f g : MulEquiv M N} : f = g ↔ ∀ x, f x = g x :=
   FunLike.ext_iff

chore(Algebra/Hom/Equiv): Update SHA per mathlib#17827 (#1396)

Paired with mathlib#17827

6ed8a7f4

Diff

@@ -5,7 +5,7 @@ Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
 Ported by: Winston Yin
 
 ! This file was ported from Lean 3 source module algebra.hom.equiv.basic
-! leanprover-community/mathlib commit 76171581280d5b5d1e2d1f4f37e5420357bdc636
+! leanprover-community/mathlib commit 67f362670ed961bcb80239dc40ca18bcd4289c77
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/

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

@@ -494,7 +494,7 @@ protected theorem congr_fun {f g : MulEquiv M N} (h : f = g) (x : M) : f x = g x
 #align add_equiv.congr_fun AddEquiv.congr_fun
 
 /-- The `MulEquiv` between two monoids with a unique element. -/
-@[to_additive "The `AddEquiv` between two add_monoids with a unique element."]
+@[to_additive "The `AddEquiv` between two `AddMonoid`s with a unique element."]
 def mulEquivOfUnique {M N} [Unique M] [Unique N] [Mul M] [Mul N] : M ≃* N :=
   { Equiv.equivOfUnique M N with map_mul' := fun _ _ => Subsingleton.elim _ _ }
 #align mul_equiv.mul_equiv_of_unique MulEquiv.mulEquivOfUnique

feat: port Algebra.Ring.Equiv (#1077)

See discussion here and there

I used #835 as a reference

depends on: #1150

Co-authored-by: ChrisHughes24 <chrishughes24@gmail.com>

84ee4ca8

Diff

@@ -572,7 +572,7 @@ def toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) : M →* N
 
 @[simp, to_additive]
 theorem coe_toMonoidHom {M N} [MulOneClass M] [MulOneClass N] (e : M ≃* N) :
-  ↑e.toMonoidHom = ↑e := rfl
+  ↑e.toMonoidHom = ⇑e := rfl
 #align mul_equiv.coe_to_monoid_hom MulEquiv.coe_toMonoidHom
 #align add_equiv.coe_to_add_monoid_hom AddEquiv.coe_toAddMonoidHom

feat: better coercions from hom classes to hom types (#1150)

Discussed here

e8655308

Diff

@@ -157,14 +157,19 @@ theorem map_ne_one_iff {M N} [MulOneClass M] [MulOneClass N] [MulEquivClass F M
 
 end MulEquivClass
 
-@[to_additive]
+/-- Turn an element of a type `F` satisfying `MulEquivClass F α β` into an actual
+`MulEquiv`. This is declared as the default coercion from `F` to `α ≃* β`. -/
+@[coe, to_additive "Turn an element of a type `F` satisfying `AddEquivClass F α β` into an actual
+`AddEquiv`. This is declared as the default coercion from `F` to `α ≃+ β`."]
+def MulEquivClass.toMulEquiv [Mul α] [Mul β] [MulEquivClass F α β] (f : F) : α ≃* β :=
+{ (f : α ≃ β), (f : α →ₙ* β) with }
+
+/-- Any type satisfying `MulEquivClass` can be cast into `MulEquiv` via
+`MulEquivClass.toMulEquiv`. -/
+@[to_additive "Any type satisfying `AddEquivClass` can be cast into `AddEquiv` via
+`AddEquivClass.toAddEquiv`. "]
 instance [Mul α] [Mul β] [MulEquivClass F α β] : CoeTC F (α ≃* β) :=
-  ⟨fun f =>
-    { toFun := f,
-      invFun := EquivLike.inv f,
-      left_inv := EquivLike.left_inv f,
-      right_inv := EquivLike.right_inv f,
-      map_mul' := MulEquivClass.map_mul f }⟩
+  ⟨MulEquivClass.toMulEquiv⟩
 
 namespace MulEquiv

fix: reintroduce to_fun_as_coe as simp lemma (#931)

This is a proposed fix for the broken simp calls in #922. See https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/.60simp.60.20calls.20broken.20in.20mathlib4.23922/near/314783451 for more details. Note that to_fun_as_coe was a syntactic tautology when it was ported, but this is no longer the case because we now have FunLike.

a2d69bdf

Diff

@@ -529,8 +529,10 @@ theorem map_ne_one_iff {M N} [MulOneClass M] [MulOneClass N] (h : M ≃* N) {x :
 #align mul_equiv.map_ne_one_iff MulEquiv.map_ne_one_iff
 #align add_equiv.map_ne_zero_iff AddEquiv.map_ne_zero_iff
 
+-- porting note: Mathlib 3 had `@[simps apply]` but right now in Lean 4 it's generating
+-- simp lemmas which don't lint.
 /-- A bijective `Semigroup` homomorphism is an isomorphism -/
-@[to_additive "A bijective `AddSemigroup` homomorphism is an isomorphism", simps apply]
+@[to_additive "A bijective `AddSemigroup` homomorphism is an isomorphism"]
 noncomputable def ofBijective {M N F} [Mul M] [Mul N] [MulHomClass F M N]
 (f : F) (hf : Function.Bijective f) :
     M ≃* N :=
@@ -538,11 +540,20 @@ noncomputable def ofBijective {M N F} [Mul M] [Mul N] [MulHomClass F M N]
 #align mul_equiv.of_bijective MulEquiv.ofBijective
 #align add_equiv.of_bijective AddEquiv.ofBijective
 
-@[simp]
+-- porting note: `@[simps apply]` should be making this lemma but it actually makes
+-- a lemma with `toFun` which isn't in simp normal form.
+@[simp, to_additive] theorem ofBijective_apply {M N F} [Mul M] [Mul N] [MulHomClass F M N]
+    (f : F) (hf : Function.Bijective f) (a : M) : (MulEquiv.ofBijective f hf).toEquiv a = f a :=
+  rfl
+#align mul_equiv.of_bijective_apply MulEquiv.ofBijective_apply
+#align add_equiv.of_bijective_apply AddEquiv.ofBijective_apply
+
+@[simp, to_additive]
 theorem ofBijective_apply_symm_apply {M N} [MulOneClass M] [MulOneClass N] {n : N} (f : M →* N)
     (hf : Function.Bijective f) : f ((Equiv.ofBijective f hf).symm n) = n :=
   (MulEquiv.ofBijective f hf).apply_symm_apply n
 #align mul_equiv.of_bijective_apply_symm_apply MulEquiv.ofBijective_apply_symm_apply
+#align add_equiv.of_bijective_apply_symm_apply AddEquiv.ofBijective_apply_symm_apply
 
 /-- Extract the forward direction of a multiplicative equivalence
 as a multiplication-preserving function.
@@ -589,8 +600,9 @@ for multiplicative maps from a monoid to a commutative monoid.
 -/
 @[to_additive
   "An additive analogue of `Equiv.arrowCongr`,
-  for additive maps from an additive monoid to a commutative additive monoid.",
-  simps apply]
+  for additive maps from an additive monoid to a commutative additive monoid."]
+-- porting note: @[simps apply] removed because it was making a lemma which
+-- wasn't in simp normal form.
 def monoidHomCongr {M N P Q} [MulOneClass M] [MulOneClass N] [CommMonoid P] [CommMonoid Q]
   (f : M ≃* N) (g : P ≃* Q) :
   (M →* P) ≃* (N →* Q) where
@@ -602,6 +614,14 @@ def monoidHomCongr {M N P Q} [MulOneClass M] [MulOneClass N] [CommMonoid P] [Com
 #align mul_equiv.monoid_hom_congr MulEquiv.monoidHomCongr
 #align add_equiv.add_monoid_hom_congr AddEquiv.addMonoidHomCongr
 
+@[simp, to_additive] theorem monoidHomCongr_apply {M N P Q} [MulOneClass M] [MulOneClass N]
+    [CommMonoid P] [CommMonoid Q] (f : M ≃* N) (g : P ≃* Q) (h : M →* P) :
+    (MulEquiv.monoidHomCongr f g).toEquiv h = MonoidHom.comp (MulEquiv.toMonoidHom g)
+    (MonoidHom.comp h (MulEquiv.toMonoidHom (MulEquiv.symm f))) :=
+  rfl
+#align mul_equiv.monoid_hom_congr_apply MulEquiv.monoidHomCongr_apply
+#align add_equiv.add_monoid_hom_congr_apply AddEquiv.addMonoidHomCongr_apply
+
 /-- A family of multiplicative equivalences `Π j, (Ms j ≃* Ns j)` generates a
 multiplicative equivalence between `Π j, Ms j` and `Π j, Ns j`.
 
@@ -647,14 +667,29 @@ theorem piCongrRight_trans {η : Type _} {Ms Ns Ps : η → Type _} [∀ j, Mul
 index. -/
 @[to_additive
   "A family indexed by a nonempty subsingleton type is
-  equivalent to the element at the single index.",
-  simps]
+  equivalent to the element at the single index."]
 def piSubsingleton {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)] [Subsingleton ι]
   (i : ι) : (∀ j, M j) ≃* M i :=
   { Equiv.piSubsingleton M i with map_mul' := fun _ _ => Pi.mul_apply _ _ _ }
 #align mul_equiv.Pi_subsingleton MulEquiv.piSubsingleton
 #align add_equiv.Pi_subsingleton AddEquiv.piSubsingleton
 
+-- porting note: the next two lemmas should be being generated by `@[to_additive, simps]`.
+-- They are added manually because `@[simps]` is currently generating lemmas with `toFun` in
+@[simp, to_additive] theorem piSubsingleton_apply {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)]
+    [Subsingleton ι] (i : ι) (f : (x : ι) → M x) : (MulEquiv.piSubsingleton M i).toEquiv f = f i :=
+  rfl
+#align mul_equiv.Pi_subsingleton_apply MulEquiv.piSubsingleton_apply
+#align add_equiv.Pi_subsingleton_apply AddEquiv.piSubsingleton_apply
+
+@[simp, to_additive] theorem piSubsingleton_symmApply {ι : Type _} (M : ι → Type _) [∀ j, Mul (M j)]
+    [Subsingleton ι] (i : ι) (x : M i) (b : ι) :
+    (MulEquiv.symm (MulEquiv.piSubsingleton M i)) x b =
+    cast (Subsingleton.elim i b ▸ rfl : M i = M b) x :=
+rfl
+#align mul_equiv.Pi_subsingleton_symmApply MulEquiv.piSubsingleton_symmApply
+#align add_equiv.Pi_subsingleton_symmApply AddEquiv.piSubsingleton_symmApply
+
 /-!
 # Groups
 -/
@@ -677,6 +712,10 @@ protected theorem map_div [Group G] [DivisionMonoid H] (h : G ≃* H) (x y : G)
 
 end MulEquiv
 
+-- porting note: we want to add
+-- `@[simps (config := { fullyApplied := false })]`
+-- here, but it generates simp lemmas which aren't in simp normal form
+-- (they have `toFun` in)
 /-- Given a pair of multiplicative homomorphisms `f`, `g` such that `g.comp f = id` and
 `f.comp g = id`, returns an multiplicative equivalence with `toFun = f` and `invFun = g`. This
 constructor is useful if the underlying type(s) have specialized `ext` lemmas for multiplicative
@@ -685,8 +724,7 @@ homomorphisms. -/
   "Given a pair of additive homomorphisms `f`, `g` such that `g.comp f = id` and
   `f.comp g = id`, returns an additive equivalence with `toFun = f` and `invFun = g`. This
   constructor is useful if the underlying type(s) have specialized `ext` lemmas for additive
-  homomorphisms.",
-  simps (config := { fullyApplied := false })]
+  homomorphisms."]
 def MulHom.toMulEquiv [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M) (h₁ : g.comp f = MulHom.id _)
   (h₂ : f.comp g = MulHom.id _) : M ≃* N where
   toFun := f
@@ -697,6 +735,24 @@ def MulHom.toMulEquiv [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M) (h₁
 #align mul_hom.to_mul_equiv MulHom.toMulEquiv
 #align add_hom.to_add_equiv AddHom.toAddEquiv
 
+-- porting note: the next two lemmas were added manually because `@[simps]` is generating
+-- lemmas with `toFun` in
+@[simp, to_additive] theorem MulHom.toMulEquiv_apply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M)
+    (h₁ : g.comp f = MulHom.id _) (h₂ : f.comp g = MulHom.id _) :
+    ((MulHom.toMulEquiv f g h₁ h₂).toEquiv : M → N) = f :=
+  rfl
+#align mul_hom.to_mul_equiv_apply MulHom.toMulEquiv_apply
+#align add_hom.to_add_equiv_apply AddHom.toAddEquiv_apply
+
+@[simp, to_additive] theorem MulHom.toMulEquiv_symmApply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M)
+    (h₁ : g.comp f = MulHom.id _) (h₂ : f.comp g = MulHom.id _) :
+    (MulEquiv.symm (MulHom.toMulEquiv f g h₁ h₂) : N → M) = ↑g :=
+  rfl
+#align mul_hom.to_mul_equiv_symm_apply MulHom.toMulEquiv_symmApply
+#align add_hom.to_add_equiv_symm_apply AddHom.toAddEquiv_symmApply
+
+-- porting note: `@[simps (config := { fullyApplied := false })]` generates a simp lemma
+-- which is not in simp normal form, so we add them manually
 /-- Given a pair of monoid homomorphisms `f`, `g` such that `g.comp f = id` and `f.comp g = id`,
 returns an multiplicative equivalence with `toFun = f` and `invFun = g`.  This constructor is
 useful if the underlying type(s) have specialized `ext` lemmas for monoid homomorphisms. -/
@@ -704,8 +760,7 @@ useful if the underlying type(s) have specialized `ext` lemmas for monoid homomo
   "Given a pair of additive monoid homomorphisms `f`, `g` such that `g.comp f = id`
   and `f.comp g = id`, returns an additive equivalence with `toFun = f` and `invFun = g`.  This
   constructor is useful if the underlying type(s) have specialized `ext` lemmas for additive
-  monoid homomorphisms.",
-  simps (config := { fullyApplied := false })]
+  monoid homomorphisms."]
 def MonoidHom.toMulEquiv [MulOneClass M] [MulOneClass N] (f : M →* N) (g : N →* M)
   (h₁ : g.comp f = MonoidHom.id _) (h₂ : f.comp g = MonoidHom.id _) : M ≃* N where
   toFun := f
@@ -716,6 +771,23 @@ def MonoidHom.toMulEquiv [MulOneClass M] [MulOneClass N] (f : M →* N) (g : N 
 #align monoid_hom.to_mul_equiv MonoidHom.toMulEquiv
 #align add_monoid_hom.to_add_mul_equiv AddMonoidHom.toAddEquiv
 
+-- porting note: the next 2 lemmas should be being generated by
+-- `@[to_additive, simps (config := { fullyApplied := false })]`
+-- but right now it's generating `simp` lemmas which aren't in `simp` normal form.
+@[simp, to_additive] theorem MonoidHom.toMulEquiv_apply [MulOneClass M] [MulOneClass N] (f : M →* N)
+    (g : N →* M) (h₁ : g.comp f = MonoidHom.id _) (h₂ : f.comp g = MonoidHom.id _) :
+    ((MonoidHom.toMulEquiv f g h₁ h₂).toEquiv : M → N) = ↑f :=
+  rfl
+#align monoid_hom.to_mul_equiv_apply MonoidHom.toMulEquiv_apply
+#align add_monoid_hom.to_add_equiv_apply AddMonoidHom.toAddEquiv_apply
+
+@[simp, to_additive] theorem MonoidHom.toMulEquiv_symmApply [MulOneClass M] [MulOneClass N]
+    (f : M →* N) (g : N →* M) (h₁ : g.comp f = MonoidHom.id _) (h₂ : f.comp g = MonoidHom.id _) :
+    (MulEquiv.symm (MonoidHom.toMulEquiv f g h₁ h₂) : N → M) = g :=
+  rfl
+#align monoid_hom.to_mul_equiv_symm_apply MonoidHom.toMulEquiv_symmApply
+#align add_monoid_hom.to_add_equiv_symm_apply AddMonoidHom.toAddEquiv_symmApply
+
 namespace Equiv
 
 section InvolutiveInv