data.int.absolute_value ⟷ Mathlib.Data.Int.AbsoluteValue

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

@@ -35,11 +35,11 @@ theorem AbsoluteValue.map_units_int (abv : AbsoluteValue ℤ S) (x : ℤˣ) : ab
 #align absolute_value.map_units_int AbsoluteValue.map_units_int
 -/
 
-#print AbsoluteValue.map_units_int_cast /-
+#print AbsoluteValue.map_units_intCast /-
 @[simp]
-theorem AbsoluteValue.map_units_int_cast [Nontrivial R] (abv : AbsoluteValue R S) (x : ℤˣ) :
+theorem AbsoluteValue.map_units_intCast [Nontrivial R] (abv : AbsoluteValue R S) (x : ℤˣ) :
     abv ((x : ℤ) : R) = 1 := by rcases Int.units_eq_one_or x with (rfl | rfl) <;> simp
-#align absolute_value.map_units_int_cast AbsoluteValue.map_units_int_cast
+#align absolute_value.map_units_int_cast AbsoluteValue.map_units_intCast
 -/
 
 #print AbsoluteValue.map_units_int_smul /-

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

@@ -3,11 +3,11 @@ Copyright (c) 2021 Anne Baanen. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anne Baanen
 -/
-import Mathbin.Algebra.Module.Basic
-import Mathbin.Algebra.Order.AbsoluteValue
-import Mathbin.Data.Int.Cast.Lemmas
-import Mathbin.Data.Int.Units
-import Mathbin.GroupTheory.GroupAction.Units
+import Algebra.Module.Basic
+import Algebra.Order.AbsoluteValue
+import Data.Int.Cast.Lemmas
+import Data.Int.Units
+import GroupTheory.GroupAction.Units
 
 #align_import data.int.absolute_value from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
 

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

@@ -2,11 +2,6 @@
 Copyright (c) 2021 Anne Baanen. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anne Baanen
-
-! This file was ported from Lean 3 source module data.int.absolute_value
-! leanprover-community/mathlib commit c3291da49cfa65f0d43b094750541c0731edc932
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Module.Basic
 import Mathbin.Algebra.Order.AbsoluteValue
@@ -14,6 +9,8 @@ import Mathbin.Data.Int.Cast.Lemmas
 import Mathbin.Data.Int.Units
 import Mathbin.GroupTheory.GroupAction.Units
 
+#align_import data.int.absolute_value from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
+
 /-!
 # Absolute values and the integers
 

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

@@ -31,21 +31,28 @@ This file contains some results on absolute values applied to integers.
 
 variable {R S : Type _} [Ring R] [LinearOrderedCommRing S]
 
+#print AbsoluteValue.map_units_int /-
 @[simp]
 theorem AbsoluteValue.map_units_int (abv : AbsoluteValue ℤ S) (x : ℤˣ) : abv x = 1 := by
   rcases Int.units_eq_one_or x with (rfl | rfl) <;> simp
 #align absolute_value.map_units_int AbsoluteValue.map_units_int
+-/
 
+#print AbsoluteValue.map_units_int_cast /-
 @[simp]
 theorem AbsoluteValue.map_units_int_cast [Nontrivial R] (abv : AbsoluteValue R S) (x : ℤˣ) :
     abv ((x : ℤ) : R) = 1 := by rcases Int.units_eq_one_or x with (rfl | rfl) <;> simp
 #align absolute_value.map_units_int_cast AbsoluteValue.map_units_int_cast
+-/
 
+#print AbsoluteValue.map_units_int_smul /-
 @[simp]
 theorem AbsoluteValue.map_units_int_smul (abv : AbsoluteValue R S) (x : ℤˣ) (y : R) :
     abv (x • y) = abv y := by rcases Int.units_eq_one_or x with (rfl | rfl) <;> simp
 #align absolute_value.map_units_int_smul AbsoluteValue.map_units_int_smul
+-/
 
+#print Int.natAbsHom /-
 /-- `int.nat_abs` as a bundled monoid with zero hom. -/
 @[simps]
 def Int.natAbsHom : ℤ →*₀ ℕ where
@@ -54,4 +61,5 @@ def Int.natAbsHom : ℤ →*₀ ℕ where
   map_one' := Int.natAbs_one
   map_zero' := Int.natAbs_zero
 #align int.nat_abs_hom Int.natAbsHom
+-/
 

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

@@ -31,45 +31,21 @@ This file contains some results on absolute values applied to integers.
 
 variable {R S : Type _} [Ring R] [LinearOrderedCommRing S]
 
-/- warning: absolute_value.map_units_int -> AbsoluteValue.map_units_int is a dubious translation:
-lean 3 declaration is
-  forall {S : Type.{u1}} [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) (x : Units.{0} Int Int.monoid), Eq.{succ u1} S (coeFn.{succ u1, succ u1} (AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) (fun (f : AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) => Int -> S) (AbsoluteValue.hasCoeToFun.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) abv ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Units.{0} Int Int.monoid) Int (HasLiftT.mk.{1, 1} (Units.{0} Int Int.monoid) Int (CoeTCₓ.coe.{1, 1} (Units.{0} Int Int.monoid) Int (coeBase.{1, 1} (Units.{0} Int Int.monoid) Int (Units.hasCoe.{0} Int Int.monoid)))) x)) (OfNat.ofNat.{u1} S 1 (OfNat.mk.{u1} S 1 (One.one.{u1} S (AddMonoidWithOne.toOne.{u1} S (AddGroupWithOne.toAddMonoidWithOne.{u1} S (AddCommGroupWithOne.toAddGroupWithOne.{u1} S (Ring.toAddCommGroupWithOne.{u1} S (StrictOrderedRing.toRing.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))))))))
-but is expected to have type
-  forall {S : Type.{u1}} [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (FunLike.coe.{succ u1, 1, succ u1} (AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) Int (fun (f : Int) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) f) (SubadditiveHomClass.toFunLike.{u1, 0, u1} (AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) Int S (Distrib.toAdd.{0} Int (NonUnitalNonAssocSemiring.toDistrib.{0} Int (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} Int (Semiring.toNonAssocSemiring.{0} Int Int.instSemiringInt)))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (Units.val.{0} Int Int.instMonoidInt x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (Semiring.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (StrictOrderedSemiring.toSemiring.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedSemiring.toStrictOrderedSemiring.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedCommSemiring.toLinearOrderedSemiring.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) _inst_2)))))))
-Case conversion may be inaccurate. Consider using '#align absolute_value.map_units_int AbsoluteValue.map_units_intₓ'. -/
 @[simp]
 theorem AbsoluteValue.map_units_int (abv : AbsoluteValue ℤ S) (x : ℤˣ) : abv x = 1 := by
   rcases Int.units_eq_one_or x with (rfl | rfl) <;> simp
 #align absolute_value.map_units_int AbsoluteValue.map_units_int
 
-/- warning: absolute_value.map_units_int_cast -> AbsoluteValue.map_units_int_cast is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : Ring.{u1} R] [_inst_2 : LinearOrderedCommRing.{u2} S] [_inst_3 : Nontrivial.{u1} R] (abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (x : Units.{0} Int Int.monoid), Eq.{succ u2} S (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) abv ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int R (HasLiftT.mk.{1, succ u1} Int R (CoeTCₓ.coe.{1, succ u1} Int R (Int.castCoe.{u1} R (AddGroupWithOne.toHasIntCast.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_1)))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Units.{0} Int Int.monoid) Int (HasLiftT.mk.{1, 1} (Units.{0} Int Int.monoid) Int (CoeTCₓ.coe.{1, 1} (Units.{0} Int Int.monoid) Int (coeBase.{1, 1} (Units.{0} Int Int.monoid) Int (Units.hasCoe.{0} Int Int.monoid)))) x))) (OfNat.ofNat.{u2} S 1 (OfNat.mk.{u2} S 1 (One.one.{u2} S (AddMonoidWithOne.toOne.{u2} S (AddGroupWithOne.toAddMonoidWithOne.{u2} S (AddCommGroupWithOne.toAddGroupWithOne.{u2} S (Ring.toAddCommGroupWithOne.{u2} S (StrictOrderedRing.toRing.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))))))))
-but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : Ring.{u2} R] [_inst_2 : LinearOrderedCommRing.{u1} S] [_inst_3 : Nontrivial.{u2} R] (abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (Semiring.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (StrictOrderedSemiring.toSemiring.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedSemiring.toStrictOrderedSemiring.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedCommSemiring.toLinearOrderedSemiring.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) _inst_2)))))))
-Case conversion may be inaccurate. Consider using '#align absolute_value.map_units_int_cast AbsoluteValue.map_units_int_castₓ'. -/
 @[simp]
 theorem AbsoluteValue.map_units_int_cast [Nontrivial R] (abv : AbsoluteValue R S) (x : ℤˣ) :
     abv ((x : ℤ) : R) = 1 := by rcases Int.units_eq_one_or x with (rfl | rfl) <;> simp
 #align absolute_value.map_units_int_cast AbsoluteValue.map_units_int_cast
 
-/- warning: absolute_value.map_units_int_smul -> AbsoluteValue.map_units_int_smul is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : Ring.{u1} R] [_inst_2 : LinearOrderedCommRing.{u2} S] (abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (x : Units.{0} Int Int.monoid) (y : R), Eq.{succ u2} S (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) abv (SMul.smul.{0, u1} (Units.{0} Int Int.monoid) R (Units.hasSmul.{0, u1} Int R Int.monoid (SubNegMonoid.SMulInt.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_1)))))) x y)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) abv y)
-but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : Ring.{u2} R] [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt) (y : R), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HSMul.hSMul.{0, u2, u2} (Units.{0} Int Int.instMonoidInt) R R (instHSMul.{0, u2} (Units.{0} Int Int.instMonoidInt) R (Units.instSMulUnits.{0, u2} Int R Int.instMonoidInt (SubNegMonoid.SMulInt.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddGroupWithOne.toAddGroup.{u2} R (Ring.toAddGroupWithOne.{u2} R _inst_1)))))) x y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (HSMul.hSMul.{0, u2, u2} (Units.{0} Int Int.instMonoidInt) R R (instHSMul.{0, u2} (Units.{0} Int Int.instMonoidInt) R (Units.instSMulUnits.{0, u2} Int R Int.instMonoidInt (SubNegMonoid.SMulInt.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddGroupWithOne.toAddGroup.{u2} R (Ring.toAddGroupWithOne.{u2} R _inst_1)))))) x y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv y)
-Case conversion may be inaccurate. Consider using '#align absolute_value.map_units_int_smul AbsoluteValue.map_units_int_smulₓ'. -/
 @[simp]
 theorem AbsoluteValue.map_units_int_smul (abv : AbsoluteValue R S) (x : ℤˣ) (y : R) :
     abv (x • y) = abv y := by rcases Int.units_eq_one_or x with (rfl | rfl) <;> simp
 #align absolute_value.map_units_int_smul AbsoluteValue.map_units_int_smul
 
-/- warning: int.nat_abs_hom -> Int.natAbsHom is a dubious translation:
-lean 3 declaration is
-  MonoidWithZeroHom.{0, 0} Int Nat (NonAssocSemiring.toMulZeroOneClass.{0} Int (NonAssocRing.toNonAssocSemiring.{0} Int (Ring.toNonAssocRing.{0} Int Int.ring))) (NonAssocSemiring.toMulZeroOneClass.{0} Nat (Semiring.toNonAssocSemiring.{0} Nat Nat.semiring))
-but is expected to have type
-  MonoidWithZeroHom.{0, 0} Int Nat (NonAssocSemiring.toMulZeroOneClass.{0} Int (Semiring.toNonAssocSemiring.{0} Int Int.instSemiringInt)) (NonAssocSemiring.toMulZeroOneClass.{0} Nat (Semiring.toNonAssocSemiring.{0} Nat Nat.semiring))
-Case conversion may be inaccurate. Consider using '#align int.nat_abs_hom Int.natAbsHomₓ'. -/
 /-- `int.nat_abs` as a bundled monoid with zero hom. -/
 @[simps]
 def Int.natAbsHom : ℤ →*₀ ℕ where

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

@@ -35,7 +35,7 @@ variable {R S : Type _} [Ring R] [LinearOrderedCommRing S]
 lean 3 declaration is
   forall {S : Type.{u1}} [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) (x : Units.{0} Int Int.monoid), Eq.{succ u1} S (coeFn.{succ u1, succ u1} (AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) (fun (f : AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) => Int -> S) (AbsoluteValue.hasCoeToFun.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) abv ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Units.{0} Int Int.monoid) Int (HasLiftT.mk.{1, 1} (Units.{0} Int Int.monoid) Int (CoeTCₓ.coe.{1, 1} (Units.{0} Int Int.monoid) Int (coeBase.{1, 1} (Units.{0} Int Int.monoid) Int (Units.hasCoe.{0} Int Int.monoid)))) x)) (OfNat.ofNat.{u1} S 1 (OfNat.mk.{u1} S 1 (One.one.{u1} S (AddMonoidWithOne.toOne.{u1} S (AddGroupWithOne.toAddMonoidWithOne.{u1} S (AddCommGroupWithOne.toAddGroupWithOne.{u1} S (Ring.toAddCommGroupWithOne.{u1} S (StrictOrderedRing.toRing.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))))))))
 but is expected to have type
-  forall {S : Type.{u1}} [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (FunLike.coe.{succ u1, 1, succ u1} (AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) Int (fun (f : Int) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) f) (SubadditiveHomClass.toFunLike.{u1, 0, u1} (AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) Int S (Distrib.toAdd.{0} Int (NonUnitalNonAssocSemiring.toDistrib.{0} Int (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} Int (Semiring.toNonAssocSemiring.{0} Int Int.instSemiringInt)))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (Units.val.{0} Int Int.instMonoidInt x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (NonAssocRing.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (StrictOrderedRing.toRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedRing.toStrictOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedCommRing.toLinearOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) _inst_2)))))))
+  forall {S : Type.{u1}} [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (FunLike.coe.{succ u1, 1, succ u1} (AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) Int (fun (f : Int) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) f) (SubadditiveHomClass.toFunLike.{u1, 0, u1} (AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) Int S (Distrib.toAdd.{0} Int (NonUnitalNonAssocSemiring.toDistrib.{0} Int (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} Int (Semiring.toNonAssocSemiring.{0} Int Int.instSemiringInt)))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (Units.val.{0} Int Int.instMonoidInt x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (Semiring.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (StrictOrderedSemiring.toSemiring.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedSemiring.toStrictOrderedSemiring.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedCommSemiring.toLinearOrderedSemiring.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) _inst_2)))))))
 Case conversion may be inaccurate. Consider using '#align absolute_value.map_units_int AbsoluteValue.map_units_intₓ'. -/
 @[simp]
 theorem AbsoluteValue.map_units_int (abv : AbsoluteValue ℤ S) (x : ℤˣ) : abv x = 1 := by
@@ -46,7 +46,7 @@ theorem AbsoluteValue.map_units_int (abv : AbsoluteValue ℤ S) (x : ℤˣ) : ab
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : Ring.{u1} R] [_inst_2 : LinearOrderedCommRing.{u2} S] [_inst_3 : Nontrivial.{u1} R] (abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (x : Units.{0} Int Int.monoid), Eq.{succ u2} S (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) abv ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int R (HasLiftT.mk.{1, succ u1} Int R (CoeTCₓ.coe.{1, succ u1} Int R (Int.castCoe.{u1} R (AddGroupWithOne.toHasIntCast.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_1)))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Units.{0} Int Int.monoid) Int (HasLiftT.mk.{1, 1} (Units.{0} Int Int.monoid) Int (CoeTCₓ.coe.{1, 1} (Units.{0} Int Int.monoid) Int (coeBase.{1, 1} (Units.{0} Int Int.monoid) Int (Units.hasCoe.{0} Int Int.monoid)))) x))) (OfNat.ofNat.{u2} S 1 (OfNat.mk.{u2} S 1 (One.one.{u2} S (AddMonoidWithOne.toOne.{u2} S (AddGroupWithOne.toAddMonoidWithOne.{u2} S (AddCommGroupWithOne.toAddGroupWithOne.{u2} S (Ring.toAddCommGroupWithOne.{u2} S (StrictOrderedRing.toRing.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))))))))
 but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : Ring.{u2} R] [_inst_2 : LinearOrderedCommRing.{u1} S] [_inst_3 : Nontrivial.{u2} R] (abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (NonAssocRing.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (StrictOrderedRing.toRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedRing.toStrictOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedCommRing.toLinearOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) _inst_2)))))))
+  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : Ring.{u2} R] [_inst_2 : LinearOrderedCommRing.{u1} S] [_inst_3 : Nontrivial.{u2} R] (abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (Semiring.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (StrictOrderedSemiring.toSemiring.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedSemiring.toStrictOrderedSemiring.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedCommSemiring.toLinearOrderedSemiring.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) _inst_2)))))))
 Case conversion may be inaccurate. Consider using '#align absolute_value.map_units_int_cast AbsoluteValue.map_units_int_castₓ'. -/
 @[simp]
 theorem AbsoluteValue.map_units_int_cast [Nontrivial R] (abv : AbsoluteValue R S) (x : ℤˣ) :
@@ -68,7 +68,7 @@ theorem AbsoluteValue.map_units_int_smul (abv : AbsoluteValue R S) (x : ℤˣ) (
 lean 3 declaration is
   MonoidWithZeroHom.{0, 0} Int Nat (NonAssocSemiring.toMulZeroOneClass.{0} Int (NonAssocRing.toNonAssocSemiring.{0} Int (Ring.toNonAssocRing.{0} Int Int.ring))) (NonAssocSemiring.toMulZeroOneClass.{0} Nat (Semiring.toNonAssocSemiring.{0} Nat Nat.semiring))
 but is expected to have type
-  MonoidWithZeroHom.{0, 0} Int Nat (NonAssocSemiring.toMulZeroOneClass.{0} Int (NonAssocRing.toNonAssocSemiring.{0} Int (Ring.toNonAssocRing.{0} Int Int.instRingInt))) (NonAssocSemiring.toMulZeroOneClass.{0} Nat (Semiring.toNonAssocSemiring.{0} Nat Nat.semiring))
+  MonoidWithZeroHom.{0, 0} Int Nat (NonAssocSemiring.toMulZeroOneClass.{0} Int (Semiring.toNonAssocSemiring.{0} Int Int.instSemiringInt)) (NonAssocSemiring.toMulZeroOneClass.{0} Nat (Semiring.toNonAssocSemiring.{0} Nat Nat.semiring))
 Case conversion may be inaccurate. Consider using '#align int.nat_abs_hom Int.natAbsHomₓ'. -/
 /-- `int.nat_abs` as a bundled monoid with zero hom. -/
 @[simps]

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

@@ -33,7 +33,7 @@ variable {R S : Type _} [Ring R] [LinearOrderedCommRing S]
 
 /- warning: absolute_value.map_units_int -> AbsoluteValue.map_units_int is a dubious translation:
 lean 3 declaration is
-  forall {S : Type.{u1}} [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) (x : Units.{0} Int Int.monoid), Eq.{succ u1} S (coeFn.{succ u1, succ u1} (AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) (fun (f : AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) => Int -> S) (AbsoluteValue.hasCoeToFun.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) abv ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Units.{0} Int Int.monoid) Int (HasLiftT.mk.{1, 1} (Units.{0} Int Int.monoid) Int (CoeTCₓ.coe.{1, 1} (Units.{0} Int Int.monoid) Int (coeBase.{1, 1} (Units.{0} Int Int.monoid) Int (Units.hasCoe.{0} Int Int.monoid)))) x)) (OfNat.ofNat.{u1} S 1 (OfNat.mk.{u1} S 1 (One.one.{u1} S (AddMonoidWithOne.toOne.{u1} S (AddGroupWithOne.toAddMonoidWithOne.{u1} S (NonAssocRing.toAddGroupWithOne.{u1} S (Ring.toNonAssocRing.{u1} S (StrictOrderedRing.toRing.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))))))))
+  forall {S : Type.{u1}} [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) (x : Units.{0} Int Int.monoid), Eq.{succ u1} S (coeFn.{succ u1, succ u1} (AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) (fun (f : AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) => Int -> S) (AbsoluteValue.hasCoeToFun.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) abv ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Units.{0} Int Int.monoid) Int (HasLiftT.mk.{1, 1} (Units.{0} Int Int.monoid) Int (CoeTCₓ.coe.{1, 1} (Units.{0} Int Int.monoid) Int (coeBase.{1, 1} (Units.{0} Int Int.monoid) Int (Units.hasCoe.{0} Int Int.monoid)))) x)) (OfNat.ofNat.{u1} S 1 (OfNat.mk.{u1} S 1 (One.one.{u1} S (AddMonoidWithOne.toOne.{u1} S (AddGroupWithOne.toAddMonoidWithOne.{u1} S (AddCommGroupWithOne.toAddGroupWithOne.{u1} S (Ring.toAddCommGroupWithOne.{u1} S (StrictOrderedRing.toRing.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))))))))
 but is expected to have type
   forall {S : Type.{u1}} [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (FunLike.coe.{succ u1, 1, succ u1} (AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) Int (fun (f : Int) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) f) (SubadditiveHomClass.toFunLike.{u1, 0, u1} (AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) Int S (Distrib.toAdd.{0} Int (NonUnitalNonAssocSemiring.toDistrib.{0} Int (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} Int (Semiring.toNonAssocSemiring.{0} Int Int.instSemiringInt)))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (Units.val.{0} Int Int.instMonoidInt x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (NonAssocRing.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (StrictOrderedRing.toRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedRing.toStrictOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedCommRing.toLinearOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) _inst_2)))))))
 Case conversion may be inaccurate. Consider using '#align absolute_value.map_units_int AbsoluteValue.map_units_intₓ'. -/
@@ -44,7 +44,7 @@ theorem AbsoluteValue.map_units_int (abv : AbsoluteValue ℤ S) (x : ℤˣ) : ab
 
 /- warning: absolute_value.map_units_int_cast -> AbsoluteValue.map_units_int_cast is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : Ring.{u1} R] [_inst_2 : LinearOrderedCommRing.{u2} S] [_inst_3 : Nontrivial.{u1} R] (abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (x : Units.{0} Int Int.monoid), Eq.{succ u2} S (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) abv ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int R (HasLiftT.mk.{1, succ u1} Int R (CoeTCₓ.coe.{1, succ u1} Int R (Int.castCoe.{u1} R (AddGroupWithOne.toHasIntCast.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Units.{0} Int Int.monoid) Int (HasLiftT.mk.{1, 1} (Units.{0} Int Int.monoid) Int (CoeTCₓ.coe.{1, 1} (Units.{0} Int Int.monoid) Int (coeBase.{1, 1} (Units.{0} Int Int.monoid) Int (Units.hasCoe.{0} Int Int.monoid)))) x))) (OfNat.ofNat.{u2} S 1 (OfNat.mk.{u2} S 1 (One.one.{u2} S (AddMonoidWithOne.toOne.{u2} S (AddGroupWithOne.toAddMonoidWithOne.{u2} S (NonAssocRing.toAddGroupWithOne.{u2} S (Ring.toNonAssocRing.{u2} S (StrictOrderedRing.toRing.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))))))))
+  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : Ring.{u1} R] [_inst_2 : LinearOrderedCommRing.{u2} S] [_inst_3 : Nontrivial.{u1} R] (abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (x : Units.{0} Int Int.monoid), Eq.{succ u2} S (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) abv ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int R (HasLiftT.mk.{1, succ u1} Int R (CoeTCₓ.coe.{1, succ u1} Int R (Int.castCoe.{u1} R (AddGroupWithOne.toHasIntCast.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_1)))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Units.{0} Int Int.monoid) Int (HasLiftT.mk.{1, 1} (Units.{0} Int Int.monoid) Int (CoeTCₓ.coe.{1, 1} (Units.{0} Int Int.monoid) Int (coeBase.{1, 1} (Units.{0} Int Int.monoid) Int (Units.hasCoe.{0} Int Int.monoid)))) x))) (OfNat.ofNat.{u2} S 1 (OfNat.mk.{u2} S 1 (One.one.{u2} S (AddMonoidWithOne.toOne.{u2} S (AddGroupWithOne.toAddMonoidWithOne.{u2} S (AddCommGroupWithOne.toAddGroupWithOne.{u2} S (Ring.toAddCommGroupWithOne.{u2} S (StrictOrderedRing.toRing.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))))))))
 but is expected to have type
   forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : Ring.{u2} R] [_inst_2 : LinearOrderedCommRing.{u1} S] [_inst_3 : Nontrivial.{u2} R] (abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (NonAssocRing.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (StrictOrderedRing.toRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedRing.toStrictOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedCommRing.toLinearOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) _inst_2)))))))
 Case conversion may be inaccurate. Consider using '#align absolute_value.map_units_int_cast AbsoluteValue.map_units_int_castₓ'. -/
@@ -55,7 +55,7 @@ theorem AbsoluteValue.map_units_int_cast [Nontrivial R] (abv : AbsoluteValue R S
 
 /- warning: absolute_value.map_units_int_smul -> AbsoluteValue.map_units_int_smul is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : Ring.{u1} R] [_inst_2 : LinearOrderedCommRing.{u2} S] (abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (x : Units.{0} Int Int.monoid) (y : R), Eq.{succ u2} S (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) abv (SMul.smul.{0, u1} (Units.{0} Int Int.monoid) R (Units.hasSmul.{0, u1} Int R Int.monoid (SubNegMonoid.SMulInt.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))))) x y)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) abv y)
+  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : Ring.{u1} R] [_inst_2 : LinearOrderedCommRing.{u2} S] (abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (x : Units.{0} Int Int.monoid) (y : R), Eq.{succ u2} S (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) abv (SMul.smul.{0, u1} (Units.{0} Int Int.monoid) R (Units.hasSmul.{0, u1} Int R Int.monoid (SubNegMonoid.SMulInt.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_1)))))) x y)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) abv y)
 but is expected to have type
   forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : Ring.{u2} R] [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt) (y : R), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HSMul.hSMul.{0, u2, u2} (Units.{0} Int Int.instMonoidInt) R R (instHSMul.{0, u2} (Units.{0} Int Int.instMonoidInt) R (Units.instSMulUnits.{0, u2} Int R Int.instMonoidInt (SubNegMonoid.SMulInt.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddGroupWithOne.toAddGroup.{u2} R (Ring.toAddGroupWithOne.{u2} R _inst_1)))))) x y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (HSMul.hSMul.{0, u2, u2} (Units.{0} Int Int.instMonoidInt) R R (instHSMul.{0, u2} (Units.{0} Int Int.instMonoidInt) R (Units.instSMulUnits.{0, u2} Int R Int.instMonoidInt (SubNegMonoid.SMulInt.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddGroupWithOne.toAddGroup.{u2} R (Ring.toAddGroupWithOne.{u2} R _inst_1)))))) x y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv y)
 Case conversion may be inaccurate. Consider using '#align absolute_value.map_units_int_smul AbsoluteValue.map_units_int_smulₓ'. -/

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

@@ -35,7 +35,7 @@ variable {R S : Type _} [Ring R] [LinearOrderedCommRing S]
 lean 3 declaration is
   forall {S : Type.{u1}} [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) (x : Units.{0} Int Int.monoid), Eq.{succ u1} S (coeFn.{succ u1, succ u1} (AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) (fun (f : AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) => Int -> S) (AbsoluteValue.hasCoeToFun.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) abv ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Units.{0} Int Int.monoid) Int (HasLiftT.mk.{1, 1} (Units.{0} Int Int.monoid) Int (CoeTCₓ.coe.{1, 1} (Units.{0} Int Int.monoid) Int (coeBase.{1, 1} (Units.{0} Int Int.monoid) Int (Units.hasCoe.{0} Int Int.monoid)))) x)) (OfNat.ofNat.{u1} S 1 (OfNat.mk.{u1} S 1 (One.one.{u1} S (AddMonoidWithOne.toOne.{u1} S (AddGroupWithOne.toAddMonoidWithOne.{u1} S (NonAssocRing.toAddGroupWithOne.{u1} S (Ring.toNonAssocRing.{u1} S (StrictOrderedRing.toRing.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))))))))
 but is expected to have type
-  forall {S : Type.{u1}} [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (FunLike.coe.{succ u1, 1, succ u1} (AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) Int (fun (f : Int) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) f) (SubadditiveHomClass.toFunLike.{u1, 0, u1} (AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) Int S (Distrib.toAdd.{0} Int (NonUnitalNonAssocSemiring.toDistrib.{0} Int (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} Int (Semiring.toNonAssocSemiring.{0} Int Int.instSemiringInt)))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (Units.val.{0} Int Int.instMonoidInt x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (NonAssocRing.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (StrictOrderedRing.toRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedRing.toStrictOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedCommRing.toLinearOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) _inst_2)))))))
+  forall {S : Type.{u1}} [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (FunLike.coe.{succ u1, 1, succ u1} (AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) Int (fun (f : Int) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) f) (SubadditiveHomClass.toFunLike.{u1, 0, u1} (AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) Int S (Distrib.toAdd.{0} Int (NonUnitalNonAssocSemiring.toDistrib.{0} Int (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} Int (Semiring.toNonAssocSemiring.{0} Int Int.instSemiringInt)))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (Units.val.{0} Int Int.instMonoidInt x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (NonAssocRing.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (StrictOrderedRing.toRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedRing.toStrictOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedCommRing.toLinearOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) _inst_2)))))))
 Case conversion may be inaccurate. Consider using '#align absolute_value.map_units_int AbsoluteValue.map_units_intₓ'. -/
 @[simp]
 theorem AbsoluteValue.map_units_int (abv : AbsoluteValue ℤ S) (x : ℤˣ) : abv x = 1 := by
@@ -46,7 +46,7 @@ theorem AbsoluteValue.map_units_int (abv : AbsoluteValue ℤ S) (x : ℤˣ) : ab
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : Ring.{u1} R] [_inst_2 : LinearOrderedCommRing.{u2} S] [_inst_3 : Nontrivial.{u1} R] (abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (x : Units.{0} Int Int.monoid), Eq.{succ u2} S (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) abv ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int R (HasLiftT.mk.{1, succ u1} Int R (CoeTCₓ.coe.{1, succ u1} Int R (Int.castCoe.{u1} R (AddGroupWithOne.toHasIntCast.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Units.{0} Int Int.monoid) Int (HasLiftT.mk.{1, 1} (Units.{0} Int Int.monoid) Int (CoeTCₓ.coe.{1, 1} (Units.{0} Int Int.monoid) Int (coeBase.{1, 1} (Units.{0} Int Int.monoid) Int (Units.hasCoe.{0} Int Int.monoid)))) x))) (OfNat.ofNat.{u2} S 1 (OfNat.mk.{u2} S 1 (One.one.{u2} S (AddMonoidWithOne.toOne.{u2} S (AddGroupWithOne.toAddMonoidWithOne.{u2} S (NonAssocRing.toAddGroupWithOne.{u2} S (Ring.toNonAssocRing.{u2} S (StrictOrderedRing.toRing.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))))))))
 but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : Ring.{u2} R] [_inst_2 : LinearOrderedCommRing.{u1} S] [_inst_3 : Nontrivial.{u2} R] (abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (NonAssocRing.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (StrictOrderedRing.toRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedRing.toStrictOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedCommRing.toLinearOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) _inst_2)))))))
+  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : Ring.{u2} R] [_inst_2 : LinearOrderedCommRing.{u1} S] [_inst_3 : Nontrivial.{u2} R] (abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (NonAssocRing.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (StrictOrderedRing.toRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedRing.toStrictOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedCommRing.toLinearOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) _inst_2)))))))
 Case conversion may be inaccurate. Consider using '#align absolute_value.map_units_int_cast AbsoluteValue.map_units_int_castₓ'. -/
 @[simp]
 theorem AbsoluteValue.map_units_int_cast [Nontrivial R] (abv : AbsoluteValue R S) (x : ℤˣ) :
@@ -57,7 +57,7 @@ theorem AbsoluteValue.map_units_int_cast [Nontrivial R] (abv : AbsoluteValue R S
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : Ring.{u1} R] [_inst_2 : LinearOrderedCommRing.{u2} S] (abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (x : Units.{0} Int Int.monoid) (y : R), Eq.{succ u2} S (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) abv (SMul.smul.{0, u1} (Units.{0} Int Int.monoid) R (Units.hasSmul.{0, u1} Int R Int.monoid (SubNegMonoid.SMulInt.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))))) x y)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) abv y)
 but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : Ring.{u2} R] [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt) (y : R), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (HSMul.hSMul.{0, u2, u2} (Units.{0} Int Int.instMonoidInt) R R (instHSMul.{0, u2} (Units.{0} Int Int.instMonoidInt) R (Units.instSMulUnits.{0, u2} Int R Int.instMonoidInt (SubNegMonoid.SMulInt.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddGroupWithOne.toAddGroup.{u2} R (Ring.toAddGroupWithOne.{u2} R _inst_1)))))) x y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (HSMul.hSMul.{0, u2, u2} (Units.{0} Int Int.instMonoidInt) R R (instHSMul.{0, u2} (Units.{0} Int Int.instMonoidInt) R (Units.instSMulUnits.{0, u2} Int R Int.instMonoidInt (SubNegMonoid.SMulInt.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddGroupWithOne.toAddGroup.{u2} R (Ring.toAddGroupWithOne.{u2} R _inst_1)))))) x y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv y)
+  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : Ring.{u2} R] [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt) (y : R), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HSMul.hSMul.{0, u2, u2} (Units.{0} Int Int.instMonoidInt) R R (instHSMul.{0, u2} (Units.{0} Int Int.instMonoidInt) R (Units.instSMulUnits.{0, u2} Int R Int.instMonoidInt (SubNegMonoid.SMulInt.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddGroupWithOne.toAddGroup.{u2} R (Ring.toAddGroupWithOne.{u2} R _inst_1)))))) x y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (HSMul.hSMul.{0, u2, u2} (Units.{0} Int Int.instMonoidInt) R R (instHSMul.{0, u2} (Units.{0} Int Int.instMonoidInt) R (Units.instSMulUnits.{0, u2} Int R Int.instMonoidInt (SubNegMonoid.SMulInt.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddGroupWithOne.toAddGroup.{u2} R (Ring.toAddGroupWithOne.{u2} R _inst_1)))))) x y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv y)
 Case conversion may be inaccurate. Consider using '#align absolute_value.map_units_int_smul AbsoluteValue.map_units_int_smulₓ'. -/
 @[simp]
 theorem AbsoluteValue.map_units_int_smul (abv : AbsoluteValue R S) (x : ℤˣ) (y : R) :

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

@@ -35,7 +35,7 @@ variable {R S : Type _} [Ring R] [LinearOrderedCommRing S]
 lean 3 declaration is
   forall {S : Type.{u1}} [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) (x : Units.{0} Int Int.monoid), Eq.{succ u1} S (coeFn.{succ u1, succ u1} (AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) (fun (f : AbsoluteValue.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) => Int -> S) (AbsoluteValue.hasCoeToFun.{0, u1} Int S Int.semiring (StrictOrderedSemiring.toOrderedSemiring.{u1} S (StrictOrderedRing.toStrictOrderedSemiring.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))) abv ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Units.{0} Int Int.monoid) Int (HasLiftT.mk.{1, 1} (Units.{0} Int Int.monoid) Int (CoeTCₓ.coe.{1, 1} (Units.{0} Int Int.monoid) Int (coeBase.{1, 1} (Units.{0} Int Int.monoid) Int (Units.hasCoe.{0} Int Int.monoid)))) x)) (OfNat.ofNat.{u1} S 1 (OfNat.mk.{u1} S 1 (One.one.{u1} S (AddMonoidWithOne.toOne.{u1} S (AddGroupWithOne.toAddMonoidWithOne.{u1} S (NonAssocRing.toAddGroupWithOne.{u1} S (Ring.toNonAssocRing.{u1} S (StrictOrderedRing.toRing.{u1} S (LinearOrderedRing.toStrictOrderedRing.{u1} S (LinearOrderedCommRing.toLinearOrderedRing.{u1} S _inst_2))))))))))
 but is expected to have type
-  forall {S : Type.{u1}} [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (FunLike.coe.{succ u1, 1, succ u1} (AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) Int (fun (f : Int) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : Int) => S) f) (SubadditiveHomClass.toFunLike.{u1, 0, u1} (AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) Int S (Distrib.toAdd.{0} Int (NonUnitalNonAssocSemiring.toDistrib.{0} Int (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} Int (Semiring.toNonAssocSemiring.{0} Int Int.instSemiringInt)))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (Units.val.{0} Int Int.instMonoidInt x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (NonAssocRing.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (StrictOrderedRing.toRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedRing.toStrictOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedCommRing.toLinearOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) _inst_2)))))))
+  forall {S : Type.{u1}} [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (FunLike.coe.{succ u1, 1, succ u1} (AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) Int (fun (f : Int) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) f) (SubadditiveHomClass.toFunLike.{u1, 0, u1} (AbsoluteValue.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) Int S (Distrib.toAdd.{0} Int (NonUnitalNonAssocSemiring.toDistrib.{0} Int (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} Int (Semiring.toNonAssocSemiring.{0} Int Int.instSemiringInt)))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{0, u1} Int S Int.instSemiringInt (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (Units.val.{0} Int Int.instMonoidInt x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (NonAssocRing.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (StrictOrderedRing.toRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedRing.toStrictOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) (LinearOrderedCommRing.toLinearOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : Int) => S) (Units.val.{0} Int Int.instMonoidInt x)) _inst_2)))))))
 Case conversion may be inaccurate. Consider using '#align absolute_value.map_units_int AbsoluteValue.map_units_intₓ'. -/
 @[simp]
 theorem AbsoluteValue.map_units_int (abv : AbsoluteValue ℤ S) (x : ℤˣ) : abv x = 1 := by
@@ -46,7 +46,7 @@ theorem AbsoluteValue.map_units_int (abv : AbsoluteValue ℤ S) (x : ℤˣ) : ab
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : Ring.{u1} R] [_inst_2 : LinearOrderedCommRing.{u2} S] [_inst_3 : Nontrivial.{u1} R] (abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (x : Units.{0} Int Int.monoid), Eq.{succ u2} S (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) abv ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int R (HasLiftT.mk.{1, succ u1} Int R (CoeTCₓ.coe.{1, succ u1} Int R (Int.castCoe.{u1} R (AddGroupWithOne.toHasIntCast.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Units.{0} Int Int.monoid) Int (HasLiftT.mk.{1, 1} (Units.{0} Int Int.monoid) Int (CoeTCₓ.coe.{1, 1} (Units.{0} Int Int.monoid) Int (coeBase.{1, 1} (Units.{0} Int Int.monoid) Int (Units.hasCoe.{0} Int Int.monoid)))) x))) (OfNat.ofNat.{u2} S 1 (OfNat.mk.{u2} S 1 (One.one.{u2} S (AddMonoidWithOne.toOne.{u2} S (AddGroupWithOne.toAddMonoidWithOne.{u2} S (NonAssocRing.toAddGroupWithOne.{u2} S (Ring.toNonAssocRing.{u2} S (StrictOrderedRing.toRing.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))))))))
 but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : Ring.{u2} R] [_inst_2 : LinearOrderedCommRing.{u1} S] [_inst_3 : Nontrivial.{u2} R] (abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (NonAssocRing.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (StrictOrderedRing.toRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedRing.toStrictOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedCommRing.toLinearOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) _inst_2)))))))
+  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : Ring.{u2} R] [_inst_2 : LinearOrderedCommRing.{u1} S] [_inst_3 : Nontrivial.{u2} R] (abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (NonAssocRing.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (StrictOrderedRing.toRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedRing.toStrictOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) (LinearOrderedCommRing.toLinearOrderedRing.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (Int.cast.{u2} R (Ring.toIntCast.{u2} R _inst_1) (Units.val.{0} Int Int.instMonoidInt x))) _inst_2)))))))
 Case conversion may be inaccurate. Consider using '#align absolute_value.map_units_int_cast AbsoluteValue.map_units_int_castₓ'. -/
 @[simp]
 theorem AbsoluteValue.map_units_int_cast [Nontrivial R] (abv : AbsoluteValue R S) (x : ℤˣ) :
@@ -57,7 +57,7 @@ theorem AbsoluteValue.map_units_int_cast [Nontrivial R] (abv : AbsoluteValue R S
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : Ring.{u1} R] [_inst_2 : LinearOrderedCommRing.{u2} S] (abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (x : Units.{0} Int Int.monoid) (y : R), Eq.{succ u2} S (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) abv (SMul.smul.{0, u1} (Units.{0} Int Int.monoid) R (Units.hasSmul.{0, u1} Int R Int.monoid (SubNegMonoid.SMulInt.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))))) x y)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R _inst_1) (StrictOrderedSemiring.toOrderedSemiring.{u2} S (StrictOrderedRing.toStrictOrderedSemiring.{u2} S (LinearOrderedRing.toStrictOrderedRing.{u2} S (LinearOrderedCommRing.toLinearOrderedRing.{u2} S _inst_2))))) abv y)
 but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : Ring.{u2} R] [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt) (y : R), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) (HSMul.hSMul.{0, u2, u2} (Units.{0} Int Int.instMonoidInt) R R (instHSMul.{0, u2} (Units.{0} Int Int.instMonoidInt) R (Units.instSMulUnits.{0, u2} Int R Int.instMonoidInt (SubNegMonoid.SMulInt.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddGroupWithOne.toAddGroup.{u2} R (Ring.toAddGroupWithOne.{u2} R _inst_1)))))) x y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (HSMul.hSMul.{0, u2, u2} (Units.{0} Int Int.instMonoidInt) R R (instHSMul.{0, u2} (Units.{0} Int Int.instMonoidInt) R (Units.instSMulUnits.{0, u2} Int R Int.instMonoidInt (SubNegMonoid.SMulInt.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddGroupWithOne.toAddGroup.{u2} R (Ring.toAddGroupWithOne.{u2} R _inst_1)))))) x y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv y)
+  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : Ring.{u2} R] [_inst_2 : LinearOrderedCommRing.{u1} S] (abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) (x : Units.{0} Int Int.instMonoidInt) (y : R), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (HSMul.hSMul.{0, u2, u2} (Units.{0} Int Int.instMonoidInt) R R (instHSMul.{0, u2} (Units.{0} Int Int.instMonoidInt) R (Units.instSMulUnits.{0, u2} Int R Int.instMonoidInt (SubNegMonoid.SMulInt.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddGroupWithOne.toAddGroup.{u2} R (Ring.toAddGroupWithOne.{u2} R _inst_1)))))) x y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv (HSMul.hSMul.{0, u2, u2} (Units.{0} Int Int.instMonoidInt) R R (instHSMul.{0, u2} (Units.{0} Int Int.instMonoidInt) R (Units.instSMulUnits.{0, u2} Int R Int.instMonoidInt (SubNegMonoid.SMulInt.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddGroupWithOne.toAddGroup.{u2} R (Ring.toAddGroupWithOne.{u2} R _inst_1)))))) x y)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R (fun (f : R) => (fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) f) (SubadditiveHomClass.toFunLike.{max u2 u1, u2, u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2))))))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R _inst_1) (OrderedCommSemiring.toOrderedSemiring.{u1} S (StrictOrderedCommSemiring.toOrderedCommSemiring.{u1} S (LinearOrderedCommSemiring.toStrictOrderedCommSemiring.{u1} S (LinearOrderedCommRing.toLinearOrderedCommSemiring.{u1} S _inst_2)))))) abv y)
 Case conversion may be inaccurate. Consider using '#align absolute_value.map_units_int_smul AbsoluteValue.map_units_int_smulₓ'. -/
 @[simp]
 theorem AbsoluteValue.map_units_int_smul (abv : AbsoluteValue R S) (x : ℤˣ) (y : R) :

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

Similar to #12486, which did this for Algebra.Algebra.Basic.

Splits Algebra.Module.Defs off Algebra.Module.Basic. Most imports only need the Defs file, which has significantly smaller imports. The remaining Algebra.Module.Basic is now a grab-bag of unrelated results, and should probably be split further or rehomed.

This is mostly motivated by the wasted effort during minimization upon encountering Algebra.Module.Basic.

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

@@ -3,7 +3,7 @@ Copyright (c) 2021 Anne Baanen. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anne Baanen
 -/
-import Mathlib.Algebra.Module.Basic
+import Mathlib.Algebra.Module.Defs
 import Mathlib.Algebra.Order.AbsoluteValue
 import Mathlib.Data.Int.Cast.Lemmas
 import Mathlib.Data.Int.Units

Now that I am defining NNRat.cast, I want a definitive answer to this naming issue. Plenty of lemmas in mathlib already use natCast/intCast/ratCast over nat_cast/int_cast/rat_cast, and this matches with the general expectation that underscore-separated name parts correspond to a single declaration.

@@ -31,9 +31,9 @@ theorem AbsoluteValue.map_units_int (abv : AbsoluteValue ℤ S) (x : ℤˣ) : ab
 #align absolute_value.map_units_int AbsoluteValue.map_units_int
 
 @[simp]
-theorem AbsoluteValue.map_units_int_cast [Nontrivial R] (abv : AbsoluteValue R S) (x : ℤˣ) :
+theorem AbsoluteValue.map_units_intCast [Nontrivial R] (abv : AbsoluteValue R S) (x : ℤˣ) :
     abv ((x : ℤ) : R) = 1 := by rcases Int.units_eq_one_or x with (rfl | rfl) <;> simp
-#align absolute_value.map_units_int_cast AbsoluteValue.map_units_int_cast
+#align absolute_value.map_units_int_cast AbsoluteValue.map_units_intCast
 
 @[simp]
 theorem AbsoluteValue.map_units_int_smul (abv : AbsoluteValue R S) (x : ℤˣ) (y : R) :

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

This has nice performance benefits.

@@ -23,7 +23,7 @@ This file contains some results on absolute values applied to integers.
 -/
 
 
-variable {R S : Type _} [Ring R] [LinearOrderedCommRing S]
+variable {R S : Type*} [Ring R] [LinearOrderedCommRing S]
 
 @[simp]
 theorem AbsoluteValue.map_units_int (abv : AbsoluteValue ℤ S) (x : ℤˣ) : abv x = 1 := by

• depends on: #5966

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

@@ -2,11 +2,6 @@
 Copyright (c) 2021 Anne Baanen. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anne Baanen
-
-! This file was ported from Lean 3 source module data.int.absolute_value
-! leanprover-community/mathlib commit 9aba7801eeecebb61f58a5763c2b6dd1b47dc6ef
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Module.Basic
 import Mathlib.Algebra.Order.AbsoluteValue
@@ -14,6 +9,8 @@ import Mathlib.Data.Int.Cast.Lemmas
 import Mathlib.Data.Int.Units
 import Mathlib.GroupTheory.GroupAction.Units
 
+#align_import data.int.absolute_value from "leanprover-community/mathlib"@"9aba7801eeecebb61f58a5763c2b6dd1b47dc6ef"
+
 /-!
 # Absolute values and the integers
 

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)

@@ -51,3 +51,4 @@ def Int.natAbsHom : ℤ →*₀ ℕ where
   map_one' := Int.natAbs_one
   map_zero' := Int.natAbs_zero
 #align int.nat_abs_hom Int.natAbsHom
+#align int.nat_abs_hom_apply Int.natAbsHom_apply

Another quickie