ring_theory.ring_invo ⟷ Mathlib.RingTheory.RingInvo

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

@@ -3,8 +3,8 @@ Copyright (c) 2018 Andreas Swerdlow. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andreas Swerdlow, Kenny Lau
 -/
-import Mathbin.Algebra.Ring.Equiv
-import Mathbin.Algebra.Ring.Opposite
+import Algebra.Ring.Equiv
+import Algebra.Ring.Opposite
 
 #align_import ring_theory.ring_invo from "leanprover-community/mathlib"@"fac369018417f980cec5fcdafc766a69f88d8cfe"
 

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

@@ -62,7 +62,7 @@ instance (R : Type _) [Semiring R] : RingInvoClass (RingInvo R) R
   inv := invFun
   coe_injective' e f h₁ h₂ := by cases e; cases f; congr
   map_add := map_add'
-  map_mul := map_mul'
+  map_hMul := map_mul'
   left_inv := left_inv
   right_inv := right_inv
   involution := involution'

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

@@ -2,15 +2,12 @@
 Copyright (c) 2018 Andreas Swerdlow. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andreas Swerdlow, Kenny Lau
-
-! This file was ported from Lean 3 source module ring_theory.ring_invo
-! leanprover-community/mathlib commit fac369018417f980cec5fcdafc766a69f88d8cfe
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Ring.Equiv
 import Mathbin.Algebra.Ring.Opposite
 
+#align_import ring_theory.ring_invo from "leanprover-community/mathlib"@"fac369018417f980cec5fcdafc766a69f88d8cfe"
+
 /-!
 # Ring involutions
 

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

@@ -70,6 +70,7 @@ instance (R : Type _) [Semiring R] : RingInvoClass (RingInvo R) R
   right_inv := right_inv
   involution := involution'
 
+#print RingInvo.mk' /-
 /-- Construct a ring involution from a ring homomorphism. -/
 def mk' (f : R →+* Rᵐᵒᵖ) (involution : ∀ r, (f (f r).unop).unop = r) : RingInvo R :=
   { f with
@@ -78,6 +79,7 @@ def mk' (f : R →+* Rᵐᵒᵖ) (involution : ∀ r, (f (f r).unop).unop = r) :
     right_inv := fun r => MulOpposite.unop_injective <| involution _
     involution' := involution }
 #align ring_invo.mk' RingInvo.mk'
+-/
 
 /-- Helper instance for when there's too many metavariables to apply
 `fun_like.has_coe_to_fun` directly. -/
@@ -89,10 +91,12 @@ theorem toFun_eq_coe (f : RingInvo R) : f.toFun = f :=
   rfl
 #align ring_invo.to_fun_eq_coe RingInvo.toFun_eq_coe
 
+#print RingInvo.involution /-
 @[simp]
 theorem involution (f : RingInvo R) (x : R) : (f (f x).unop).unop = x :=
   f.involution' x
 #align ring_invo.involution RingInvo.involution
+-/
 
 instance hasCoeToRingEquiv : Coe (RingInvo R) (R ≃+* Rᵐᵒᵖ) :=
   ⟨RingInvo.toRingEquiv⟩
@@ -105,10 +109,12 @@ theorem coe_ringEquiv (f : RingInvo R) (a : R) : (f : R ≃+* Rᵐᵒᵖ) a = f
 #align ring_invo.coe_ring_equiv RingInvo.coe_ringEquiv
 -/
 
+#print RingInvo.map_eq_zero_iff /-
 @[simp]
 theorem map_eq_zero_iff (f : RingInvo R) {x : R} : f x = 0 ↔ x = 0 :=
   f.toRingEquiv.map_eq_zero_iff
 #align ring_invo.map_eq_zero_iff RingInvo.map_eq_zero_iff
+-/
 
 end RingInvo
 

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

@@ -50,7 +50,7 @@ add_decl_doc RingInvo.toRingEquiv
 /-- `ring_invo_class F R S` states that `F` is a type of ring involutions.
 You should extend this class when you extend `ring_invo`. -/
 class RingInvoClass (F : Type _) (R : outParam (Type _)) [Semiring R] extends
-  RingEquivClass F R Rᵐᵒᵖ where
+    RingEquivClass F R Rᵐᵒᵖ where
   involution : ∀ (f : F) (x), (f (f x).unop).unop = x
 #align ring_invo_class RingInvoClass
 -/

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

@@ -84,12 +84,10 @@ def mk' (f : R →+* Rᵐᵒᵖ) (involution : ∀ r, (f (f r).unop).unop = r) :
 instance : CoeFun (RingInvo R) fun _ => R → Rᵐᵒᵖ :=
   ⟨fun f => f.toRingEquiv.toFun⟩
 
-/- warning: ring_invo.to_fun_eq_coe clashes with [anonymous] -> [anonymous]
-Case conversion may be inaccurate. Consider using '#align ring_invo.to_fun_eq_coe [anonymous]ₓ'. -/
 @[simp]
-theorem [anonymous] (f : RingInvo R) : f.toFun = f :=
+theorem toFun_eq_coe (f : RingInvo R) : f.toFun = f :=
   rfl
-#align ring_invo.to_fun_eq_coe [anonymous]
+#align ring_invo.to_fun_eq_coe RingInvo.toFun_eq_coe
 
 @[simp]
 theorem involution (f : RingInvo R) (x : R) : (f (f x).unop).unop = x :=

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

@@ -70,12 +70,6 @@ instance (R : Type _) [Semiring R] : RingInvoClass (RingInvo R) R
   right_inv := right_inv
   involution := involution'
 
-/- warning: ring_invo.mk' -> RingInvo.mk' is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))), (forall (r : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (fun (_x : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) => R -> (MulOpposite.{u1} R)) (RingHom.hasCoeToFun.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) f (MulOpposite.unop.{u1} R (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (fun (_x : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) => R -> (MulOpposite.{u1} R)) (RingHom.hasCoeToFun.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) f r)))) r) -> (RingInvo.{u1} R _inst_1)
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))), (forall (r : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f r)))) r) -> (RingInvo.{u1} R _inst_1)
-Case conversion may be inaccurate. Consider using '#align ring_invo.mk' RingInvo.mk'ₓ'. -/
 /-- Construct a ring involution from a ring homomorphism. -/
 def mk' (f : R →+* Rᵐᵒᵖ) (involution : ∀ r, (f (f r).unop).unop = r) : RingInvo R :=
   { f with
@@ -91,23 +85,12 @@ instance : CoeFun (RingInvo R) fun _ => R → Rᵐᵒᵖ :=
   ⟨fun f => f.toRingEquiv.toFun⟩
 
 /- warning: ring_invo.to_fun_eq_coe clashes with [anonymous] -> [anonymous]
-warning: ring_invo.to_fun_eq_coe -> [anonymous] is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u_1}} [_inst_1 : Semiring.{u_1} R] (f : RingInvo.{u_1} R _inst_1), Eq.{succ u_1} (R -> (MulOpposite.{u_1} R)) (RingInvo.toFun.{u_1} R _inst_1 f) (coeFn.{succ u_1, succ u_1} (RingInvo.{u_1} R _inst_1) (fun (_x : RingInvo.{u_1} R _inst_1) => R -> (MulOpposite.{u_1} R)) (RingInvo.hasCoeToFun.{u_1} R _inst_1) f)
-but is expected to have type
-  forall {R : Type.{u}} {_inst_1 : Type.{v}}, (Nat -> R -> _inst_1) -> Nat -> (List.{u} R) -> (List.{v} _inst_1)
 Case conversion may be inaccurate. Consider using '#align ring_invo.to_fun_eq_coe [anonymous]ₓ'. -/
 @[simp]
 theorem [anonymous] (f : RingInvo R) : f.toFun = f :=
   rfl
 #align ring_invo.to_fun_eq_coe [anonymous]
 
-/- warning: ring_invo.involution -> RingInvo.involution is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingInvo.{u1} R _inst_1) (x : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (coeFn.{succ u1, succ u1} (RingInvo.{u1} R _inst_1) (fun (_x : RingInvo.{u1} R _inst_1) => R -> (MulOpposite.{u1} R)) (RingInvo.hasCoeToFun.{u1} R _inst_1) f (MulOpposite.unop.{u1} R (coeFn.{succ u1, succ u1} (RingInvo.{u1} R _inst_1) (fun (_x : RingInvo.{u1} R _inst_1) => R -> (MulOpposite.{u1} R)) (RingInvo.hasCoeToFun.{u1} R _inst_1) f x)))) x
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingInvo.{u1} R _inst_1) (x : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (fun (_x : R) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (MulEquivClass.toEquivLike.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (MulOpposite.mul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (RingEquivClass.toMulEquivClass.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.mul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.add.{u1} R (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) (RingInvoClass.toRingEquivClass.{u1, u1} (RingInvo.{u1} R _inst_1) R _inst_1 (RingInvo.instRingInvoClassRingInvo.{u1} R _inst_1)))))) f (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (fun (_x : R) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (MulEquivClass.toEquivLike.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (MulOpposite.mul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (RingEquivClass.toMulEquivClass.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.mul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.add.{u1} R (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) (RingInvoClass.toRingEquivClass.{u1, u1} (RingInvo.{u1} R _inst_1) R _inst_1 (RingInvo.instRingInvoClassRingInvo.{u1} R _inst_1)))))) f x)))) x
-Case conversion may be inaccurate. Consider using '#align ring_invo.involution RingInvo.involutionₓ'. -/
 @[simp]
 theorem involution (f : RingInvo R) (x : R) : (f (f x).unop).unop = x :=
   f.involution' x
@@ -124,12 +107,6 @@ theorem coe_ringEquiv (f : RingInvo R) (a : R) : (f : R ≃+* Rᵐᵒᵖ) a = f
 #align ring_invo.coe_ring_equiv RingInvo.coe_ringEquiv
 -/
 
-/- warning: ring_invo.map_eq_zero_iff -> RingInvo.map_eq_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingInvo.{u1} R _inst_1) {x : R}, Iff (Eq.{succ u1} (MulOpposite.{u1} R) (coeFn.{succ u1, succ u1} (RingInvo.{u1} R _inst_1) (fun (_x : RingInvo.{u1} R _inst_1) => R -> (MulOpposite.{u1} R)) (RingInvo.hasCoeToFun.{u1} R _inst_1) f x) (OfNat.ofNat.{u1} (MulOpposite.{u1} R) 0 (OfNat.mk.{u1} (MulOpposite.{u1} R) 0 (Zero.zero.{u1} (MulOpposite.{u1} R) (MulOpposite.hasZero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))))))) (Eq.{succ u1} R x (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))))))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingInvo.{u1} R _inst_1) {x : R}, Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) x) (FunLike.coe.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (fun (_x : R) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (MulEquivClass.toEquivLike.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (MulOpposite.mul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (RingEquivClass.toMulEquivClass.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.mul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.add.{u1} R (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) (RingInvoClass.toRingEquivClass.{u1, u1} (RingInvo.{u1} R _inst_1) R _inst_1 (RingInvo.instRingInvoClassRingInvo.{u1} R _inst_1)))))) f x) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) x) 0 (Zero.toOfNat0.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) x) (MulOpposite.zero.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))))) (Eq.{succ u1} R x (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align ring_invo.map_eq_zero_iff RingInvo.map_eq_zero_iffₓ'. -/
 @[simp]
 theorem map_eq_zero_iff (f : RingInvo R) {x : R} : f x = 0 ↔ x = 0 :=
   f.toRingEquiv.map_eq_zero_iff

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

@@ -63,10 +63,7 @@ instance (R : Type _) [Semiring R] : RingInvoClass (RingInvo R) R
     where
   coe := toFun
   inv := invFun
-  coe_injective' e f h₁ h₂ := by
-    cases e
-    cases f
-    congr
+  coe_injective' e f h₁ h₂ := by cases e; cases f; congr
   map_add := map_add'
   map_mul := map_mul'
   left_inv := left_inv

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

@@ -77,7 +77,7 @@ instance (R : Type _) [Semiring R] : RingInvoClass (RingInvo R) R
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))), (forall (r : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (fun (_x : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) => R -> (MulOpposite.{u1} R)) (RingHom.hasCoeToFun.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) f (MulOpposite.unop.{u1} R (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (fun (_x : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) => R -> (MulOpposite.{u1} R)) (RingHom.hasCoeToFun.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) f r)))) r) -> (RingInvo.{u1} R _inst_1)
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))), (forall (r : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f r)))) r) -> (RingInvo.{u1} R _inst_1)
+  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))), (forall (r : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f r)))) r) -> (RingInvo.{u1} R _inst_1)
 Case conversion may be inaccurate. Consider using '#align ring_invo.mk' RingInvo.mk'ₓ'. -/
 /-- Construct a ring involution from a ring homomorphism. -/
 def mk' (f : R →+* Rᵐᵒᵖ) (involution : ∀ r, (f (f r).unop).unop = r) : RingInvo R :=

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

@@ -77,7 +77,7 @@ instance (R : Type _) [Semiring R] : RingInvoClass (RingInvo R) R
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))), (forall (r : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (fun (_x : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) => R -> (MulOpposite.{u1} R)) (RingHom.hasCoeToFun.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) f (MulOpposite.unop.{u1} R (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (fun (_x : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) => R -> (MulOpposite.{u1} R)) (RingHom.hasCoeToFun.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) f r)))) r) -> (RingInvo.{u1} R _inst_1)
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))), (forall (r : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f r)))) r) -> (RingInvo.{u1} R _inst_1)
+  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))), (forall (r : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f r)))) r) -> (RingInvo.{u1} R _inst_1)
 Case conversion may be inaccurate. Consider using '#align ring_invo.mk' RingInvo.mk'ₓ'. -/
 /-- Construct a ring involution from a ring homomorphism. -/
 def mk' (f : R →+* Rᵐᵒᵖ) (involution : ∀ r, (f (f r).unop).unop = r) : RingInvo R :=
@@ -109,7 +109,7 @@ theorem [anonymous] (f : RingInvo R) : f.toFun = f :=
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingInvo.{u1} R _inst_1) (x : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (coeFn.{succ u1, succ u1} (RingInvo.{u1} R _inst_1) (fun (_x : RingInvo.{u1} R _inst_1) => R -> (MulOpposite.{u1} R)) (RingInvo.hasCoeToFun.{u1} R _inst_1) f (MulOpposite.unop.{u1} R (coeFn.{succ u1, succ u1} (RingInvo.{u1} R _inst_1) (fun (_x : RingInvo.{u1} R _inst_1) => R -> (MulOpposite.{u1} R)) (RingInvo.hasCoeToFun.{u1} R _inst_1) f x)))) x
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingInvo.{u1} R _inst_1) (x : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (fun (_x : R) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (MulEquivClass.toEquivLike.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (MulOpposite.instMulMulOpposite.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (RingEquivClass.toMulEquivClass.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.instMulMulOpposite.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.instAddMulOpposite.{u1} R (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) (RingInvoClass.toRingEquivClass.{u1, u1} (RingInvo.{u1} R _inst_1) R _inst_1 (RingInvo.instRingInvoClassRingInvo.{u1} R _inst_1)))))) f (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (fun (_x : R) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (MulEquivClass.toEquivLike.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (MulOpposite.instMulMulOpposite.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (RingEquivClass.toMulEquivClass.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.instMulMulOpposite.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.instAddMulOpposite.{u1} R (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) (RingInvoClass.toRingEquivClass.{u1, u1} (RingInvo.{u1} R _inst_1) R _inst_1 (RingInvo.instRingInvoClassRingInvo.{u1} R _inst_1)))))) f x)))) x
+  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingInvo.{u1} R _inst_1) (x : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (fun (_x : R) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (MulEquivClass.toEquivLike.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (MulOpposite.mul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (RingEquivClass.toMulEquivClass.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.mul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.add.{u1} R (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) (RingInvoClass.toRingEquivClass.{u1, u1} (RingInvo.{u1} R _inst_1) R _inst_1 (RingInvo.instRingInvoClassRingInvo.{u1} R _inst_1)))))) f (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (fun (_x : R) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (MulEquivClass.toEquivLike.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (MulOpposite.mul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (RingEquivClass.toMulEquivClass.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.mul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.add.{u1} R (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) (RingInvoClass.toRingEquivClass.{u1, u1} (RingInvo.{u1} R _inst_1) R _inst_1 (RingInvo.instRingInvoClassRingInvo.{u1} R _inst_1)))))) f x)))) x
 Case conversion may be inaccurate. Consider using '#align ring_invo.involution RingInvo.involutionₓ'. -/
 @[simp]
 theorem involution (f : RingInvo R) (x : R) : (f (f x).unop).unop = x :=
@@ -131,7 +131,7 @@ theorem coe_ringEquiv (f : RingInvo R) (a : R) : (f : R ≃+* Rᵐᵒᵖ) a = f
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingInvo.{u1} R _inst_1) {x : R}, Iff (Eq.{succ u1} (MulOpposite.{u1} R) (coeFn.{succ u1, succ u1} (RingInvo.{u1} R _inst_1) (fun (_x : RingInvo.{u1} R _inst_1) => R -> (MulOpposite.{u1} R)) (RingInvo.hasCoeToFun.{u1} R _inst_1) f x) (OfNat.ofNat.{u1} (MulOpposite.{u1} R) 0 (OfNat.mk.{u1} (MulOpposite.{u1} R) 0 (Zero.zero.{u1} (MulOpposite.{u1} R) (MulOpposite.hasZero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))))))) (Eq.{succ u1} R x (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))))))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingInvo.{u1} R _inst_1) {x : R}, Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) x) (FunLike.coe.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (fun (_x : R) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (MulEquivClass.toEquivLike.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (MulOpposite.instMulMulOpposite.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (RingEquivClass.toMulEquivClass.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.instMulMulOpposite.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.instAddMulOpposite.{u1} R (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) (RingInvoClass.toRingEquivClass.{u1, u1} (RingInvo.{u1} R _inst_1) R _inst_1 (RingInvo.instRingInvoClassRingInvo.{u1} R _inst_1)))))) f x) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) x) 0 (Zero.toOfNat0.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) x) (MulOpposite.instZeroMulOpposite.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))))) (Eq.{succ u1} R x (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))))
+  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingInvo.{u1} R _inst_1) {x : R}, Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) x) (FunLike.coe.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (fun (_x : R) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (MulEquivClass.toEquivLike.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (MulOpposite.mul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (RingEquivClass.toMulEquivClass.{u1, u1, u1} (RingInvo.{u1} R _inst_1) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.mul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (MulOpposite.add.{u1} R (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) (RingInvoClass.toRingEquivClass.{u1, u1} (RingInvo.{u1} R _inst_1) R _inst_1 (RingInvo.instRingInvoClassRingInvo.{u1} R _inst_1)))))) f x) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) x) 0 (Zero.toOfNat0.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => MulOpposite.{u1} R) x) (MulOpposite.zero.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))))) (Eq.{succ u1} R x (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))))
 Case conversion may be inaccurate. Consider using '#align ring_invo.map_eq_zero_iff RingInvo.map_eq_zero_iffₓ'. -/
 @[simp]
 theorem map_eq_zero_iff (f : RingInvo R) {x : R} : f x = 0 ↔ x = 0 :=

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

@@ -77,7 +77,7 @@ instance (R : Type _) [Semiring R] : RingInvoClass (RingInvo R) R
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))), (forall (r : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (fun (_x : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) => R -> (MulOpposite.{u1} R)) (RingHom.hasCoeToFun.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) f (MulOpposite.unop.{u1} R (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (fun (_x : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) => R -> (MulOpposite.{u1} R)) (RingHom.hasCoeToFun.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) f r)))) r) -> (RingInvo.{u1} R _inst_1)
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))), (forall (r : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f r)))) r) -> (RingInvo.{u1} R _inst_1)
+  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))), (forall (r : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f r)))) r) -> (RingInvo.{u1} R _inst_1)
 Case conversion may be inaccurate. Consider using '#align ring_invo.mk' RingInvo.mk'ₓ'. -/
 /-- Construct a ring involution from a ring homomorphism. -/
 def mk' (f : R →+* Rᵐᵒᵖ) (involution : ∀ r, (f (f r).unop).unop = r) : RingInvo R :=

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

@@ -77,7 +77,7 @@ instance (R : Type _) [Semiring R] : RingInvoClass (RingInvo R) R
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))), (forall (r : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (fun (_x : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) => R -> (MulOpposite.{u1} R)) (RingHom.hasCoeToFun.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) f (MulOpposite.unop.{u1} R (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (fun (_x : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) => R -> (MulOpposite.{u1} R)) (RingHom.hasCoeToFun.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.nonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) f r)))) r) -> (RingInvo.{u1} R _inst_1)
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))), (forall (r : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f r)))) r) -> (RingInvo.{u1} R _inst_1)
+  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] (f : RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))), (forall (r : R), Eq.{succ u1} R (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f (MulOpposite.unop.{u1} R (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (fun (_x : R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : R) => MulOpposite.{u1} R) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (MulOpposite.{u1} R) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u1} R (MulOpposite.{u1} R) (Semiring.toNonAssocSemiring.{u1} R _inst_1) (MulOpposite.instNonAssocSemiringMulOpposite.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))))) f r)))) r) -> (RingInvo.{u1} R _inst_1)
 Case conversion may be inaccurate. Consider using '#align ring_invo.mk' RingInvo.mk'ₓ'. -/
 /-- Construct a ring involution from a ring homomorphism. -/
 def mk' (f : R →+* Rᵐᵒᵖ) (involution : ∀ r, (f (f r).unop).unop = r) : RingInvo R :=

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

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

@@ -64,10 +64,10 @@ variable {R} [Semiring R] [EquivLike F R Rᵐᵒᵖ]
 
 /-- Any type satisfying `RingInvoClass` can be cast into `RingInvo` via
 `RingInvoClass.toRingInvo`. -/
-instance [Semiring R] [RingInvoClass F R] : CoeTC F (RingInvo R) :=
+instance [RingInvoClass F R] : CoeTC F (RingInvo R) :=
   ⟨RingInvoClass.toRingInvo⟩
 
-instance [Semiring R] : EquivLike (RingInvo R) R Rᵐᵒᵖ where
+instance : EquivLike (RingInvo R) R Rᵐᵒᵖ where
   coe f := f.toFun
   inv f := f.invFun
   coe_injective' e f h₁ h₂ := by
@@ -78,7 +78,7 @@ instance [Semiring R] : EquivLike (RingInvo R) R Rᵐᵒᵖ where
   left_inv f := f.left_inv
   right_inv f := f.right_inv
 
-instance [Semiring R] : RingInvoClass (RingInvo R) R where
+instance : RingInvoClass (RingInvo R) R where
   map_add f := f.map_add'
   map_mul f := f.map_mul'
   involution f := f.involution'

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".

@@ -102,7 +102,7 @@ theorem involution (f : RingInvo R) (x : R) : (f (f x).unop).unop = x :=
   f.involution' x
 #align ring_invo.involution RingInvo.involution
 
--- porting note: remove Coe instance, not needed
+-- Porting note: remove Coe instance, not needed
 -- instance hasCoeToRingEquiv : Coe (RingInvo R) (R ≃+* Rᵐᵒᵖ) :=
 --   ⟨RingInvo.toRingEquiv⟩
 -- #align ring_invo.has_coe_to_ring_equiv RingInvo.hasCoeToRingEquiv

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

@@ -112,7 +112,7 @@ theorem coe_ringEquiv (f : RingInvo R) (a : R) : (f : R ≃+* Rᵐᵒᵖ) a = f
   rfl
 #align ring_invo.coe_ring_equiv RingInvo.coe_ringEquiv
 
--- porting Note: simp can prove this
+-- porting note (#10618): simp can prove this
 -- @[simp]
 theorem map_eq_zero_iff (f : RingInvo R) {x : R} : f x = 0 ↔ x = 0 :=
   f.toRingEquiv.map_eq_zero_iff

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>

@@ -44,29 +44,30 @@ add_decl_doc RingInvo.toRingEquiv
 
 /-- `RingInvoClass F R` states that `F` is a type of ring involutions.
 You should extend this class when you extend `RingInvo`. -/
-class RingInvoClass (F : Type*) (R : outParam (Type*)) [Semiring R] extends
-    RingEquivClass F R Rᵐᵒᵖ where
+class RingInvoClass (F R : Type*) [Semiring R] [EquivLike F R Rᵐᵒᵖ]
+  extends RingEquivClass F R Rᵐᵒᵖ : Prop where
   /-- Every ring involution must be its own inverse -/
   involution : ∀ (f : F) (x), (f (f x).unop).unop = x
 #align ring_invo_class RingInvoClass
 
+
 /-- Turn an element of a type `F` satisfying `RingInvoClass F R` into an actual
 `RingInvo`. This is declared as the default coercion from `F` to `RingInvo R`. -/
 @[coe]
-def RingInvoClass.toRingInvo {R} [Semiring R] [RingInvoClass F R] (f : F) :
+def RingInvoClass.toRingInvo {R} [Semiring R] [EquivLike F R Rᵐᵒᵖ] [RingInvoClass F R] (f : F) :
     RingInvo R :=
   { (f : R ≃+* Rᵐᵒᵖ) with involution' := RingInvoClass.involution f }
 
 namespace RingInvo
 
-variable {R} [Semiring R]
+variable {R} [Semiring R] [EquivLike F R Rᵐᵒᵖ]
 
 /-- Any type satisfying `RingInvoClass` can be cast into `RingInvo` via
 `RingInvoClass.toRingInvo`. -/
 instance [Semiring R] [RingInvoClass F R] : CoeTC F (RingInvo R) :=
   ⟨RingInvoClass.toRingInvo⟩
 
-instance [Semiring R] : RingInvoClass (RingInvo R) R where
+instance [Semiring R] : EquivLike (RingInvo R) R Rᵐᵒᵖ where
   coe f := f.toFun
   inv f := f.invFun
   coe_injective' e f h₁ h₂ := by
@@ -74,10 +75,12 @@ instance [Semiring R] : RingInvoClass (RingInvo R) R where
     cases tE
     cases tF
     congr
-  map_add f := f.map_add'
-  map_mul f := f.map_mul'
   left_inv f := f.left_inv
   right_inv f := f.right_inv
+
+instance [Semiring R] : RingInvoClass (RingInvo R) R where
+  map_add f := f.map_add'
+  map_mul f := f.map_mul'
   involution f := f.involution'
 
 /-- Construct a ring involution from a ring homomorphism. -/

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

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

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

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

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

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

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

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

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

@@ -27,6 +27,8 @@ We provide a coercion to a function `R → Rᵐᵒᵖ`.
 Ring involution
 -/
 
+set_option autoImplicit true
+
 
 variable (R : Type*)
 

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

This has nice performance benefits.

@@ -28,7 +28,7 @@ Ring involution
 -/
 
 
-variable (R : Type _)
+variable (R : Type*)
 
 /-- A ring involution -/
 structure RingInvo [Semiring R] extends R ≃+* Rᵐᵒᵖ where
@@ -42,7 +42,7 @@ add_decl_doc RingInvo.toRingEquiv
 
 /-- `RingInvoClass F R` states that `F` is a type of ring involutions.
 You should extend this class when you extend `RingInvo`. -/
-class RingInvoClass (F : Type _) (R : outParam (Type _)) [Semiring R] extends
+class RingInvoClass (F : Type*) (R : outParam (Type*)) [Semiring R] extends
     RingEquivClass F R Rᵐᵒᵖ where
   /-- Every ring involution must be its own inverse -/
   involution : ∀ (f : F) (x), (f (f x).unop).unop = x

• depends on: #5966

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

@@ -2,15 +2,12 @@
 Copyright (c) 2018 Andreas Swerdlow. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andreas Swerdlow, Kenny Lau
-
-! This file was ported from Lean 3 source module ring_theory.ring_invo
-! leanprover-community/mathlib commit ec2dfcae3677bcdc0d8e906831b1d251dfcbc0f1
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Ring.Equiv
 import Mathlib.Algebra.Ring.Opposite
 
+#align_import ring_theory.ring_invo from "leanprover-community/mathlib"@"ec2dfcae3677bcdc0d8e906831b1d251dfcbc0f1"
+
 /-!
 # Ring involutions
 

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

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

@@ -46,7 +46,7 @@ add_decl_doc RingInvo.toRingEquiv
 /-- `RingInvoClass F R` states that `F` is a type of ring involutions.
 You should extend this class when you extend `RingInvo`. -/
 class RingInvoClass (F : Type _) (R : outParam (Type _)) [Semiring R] extends
-  RingEquivClass F R Rᵐᵒᵖ  where
+    RingEquivClass F R Rᵐᵒᵖ where
   /-- Every ring involution must be its own inverse -/
   involution : ∀ (f : F) (x), (f (f x).unop).unop = x
 #align ring_invo_class RingInvoClass

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

@@ -35,7 +35,7 @@ variable (R : Type _)
 
 /-- A ring involution -/
 structure RingInvo [Semiring R] extends R ≃+* Rᵐᵒᵖ where
-/-- The requirement that the ring homomorphism is its own inverse -/
+  /-- The requirement that the ring homomorphism is its own inverse -/
   involution' : ∀ x, (toFun (toFun x).unop).unop = x
 #align ring_invo RingInvo
 

Match https://github.com/leanprover-community/mathlib/pull/18175. This made it to the original port, but the SHA was wrong.

ring_theory.ring_invo@09597669f02422ed388036273d8848119699c22f..ec2dfcae3677bcdc0d8e906831b1d251dfcbc0f1

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andreas Swerdlow, Kenny Lau
 
 ! This file was ported from Lean 3 source module ring_theory.ring_invo
-! leanprover-community/mathlib commit 09597669f02422ed388036273d8848119699c22f
+! leanprover-community/mathlib commit ec2dfcae3677bcdc0d8e906831b1d251dfcbc0f1
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/

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)

@@ -41,6 +41,7 @@ structure RingInvo [Semiring R] extends R ≃+* Rᵐᵒᵖ where
 
 /-- The equivalence of rings underlying a ring involution. -/
 add_decl_doc RingInvo.toRingEquiv
+#align ring_invo.to_ring_equiv RingInvo.toRingEquiv
 
 /-- `RingInvoClass F R` states that `F` is a type of ring involutions.
 You should extend this class when you extend `RingInvo`. -/

Everything compiles properly, not done with style/removing unnecisary lemmas

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> Co-authored-by: qawbecrdtey <qawbecrdtey@kaist.ac.kr> Co-authored-by: Lukas Miaskiwskyi <lukas.mias@gmail.com> Co-authored-by: z <32079362+zaxioms@users.noreply.github.com>