algebra.order.euclidean_absolute_value ⟷ Mathlib.Algebra.Order.EuclideanAbsoluteValue

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

@@ -3,8 +3,8 @@ 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.Order.AbsoluteValue
-import Mathbin.Algebra.EuclideanDomain.Instances
+import Algebra.Order.AbsoluteValue
+import Algebra.EuclideanDomain.Instances
 
 #align_import algebra.order.euclidean_absolute_value from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
 

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

@@ -2,15 +2,12 @@
 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 algebra.order.euclidean_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.Order.AbsoluteValue
 import Mathbin.Algebra.EuclideanDomain.Instances
 
+#align_import algebra.order.euclidean_absolute_value from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
+
 /-!
 # Euclidean absolute values
 

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

@@ -29,7 +29,6 @@ absolute value is compatible with the Euclidean domain structure on its domain.
 -/
 
 
--- mathport name: «expr ≺ »
 local infixl:50 " ≺ " => EuclideanDomain.r
 
 namespace AbsoluteValue
@@ -53,16 +52,20 @@ namespace IsEuclidean
 
 variable {abv}
 
+#print AbsoluteValue.IsEuclidean.map_lt_map_iff /-
 -- Rearrange the parameters to `map_lt_map_iff'` so it elaborates better.
 theorem map_lt_map_iff {x y : R} (h : abv.IsEuclidean) : abv x < abv y ↔ x ≺ y :=
   map_lt_map_iff' h
 #align absolute_value.is_euclidean.map_lt_map_iff AbsoluteValue.IsEuclidean.map_lt_map_iff
+-/
 
 attribute [simp] map_lt_map_iff
 
+#print AbsoluteValue.IsEuclidean.sub_mod_lt /-
 theorem sub_mod_lt (h : abv.IsEuclidean) (a : R) {b : R} (hb : b ≠ 0) : abv (a % b) < abv b :=
   h.map_lt_map_iff.mpr (EuclideanDomain.mod_lt a hb)
 #align absolute_value.is_euclidean.sub_mod_lt AbsoluteValue.IsEuclidean.sub_mod_lt
+-/
 
 end IsEuclidean
 

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

@@ -53,12 +53,6 @@ namespace IsEuclidean
 
 variable {abv}
 
-/- warning: absolute_value.is_euclidean.map_lt_map_iff -> AbsoluteValue.IsEuclidean.map_lt_map_iff is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : EuclideanDomain.{u1} R] [_inst_2 : OrderedSemiring.{u2} S] {abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2} {x : R} {y : R}, (AbsoluteValue.IsEuclidean.{u1, u2} R S _inst_1 _inst_2 abv) -> (Iff (LT.lt.{u2} S (Preorder.toHasLt.{u2} S (PartialOrder.toPreorder.{u2} S (OrderedAddCommMonoid.toPartialOrder.{u2} S (OrderedSemiring.toOrderedAddCommMonoid.{u2} S _inst_2)))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv y)) (EuclideanDomain.r.{u1} R _inst_1 x y))
-but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : EuclideanDomain.{u2} R] [_inst_2 : OrderedSemiring.{u1} S] {abv : AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2} {x : R} {y : R}, (AbsoluteValue.IsEuclidean.{u2, u1} R S _inst_1 _inst_2 abv) -> (Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) (Preorder.toLT.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) (OrderedSemiring.toPartialOrder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv y)) (EuclideanDomain.r.{u2} R _inst_1 x y))
-Case conversion may be inaccurate. Consider using '#align absolute_value.is_euclidean.map_lt_map_iff AbsoluteValue.IsEuclidean.map_lt_map_iffₓ'. -/
 -- Rearrange the parameters to `map_lt_map_iff'` so it elaborates better.
 theorem map_lt_map_iff {x y : R} (h : abv.IsEuclidean) : abv x < abv y ↔ x ≺ y :=
   map_lt_map_iff' h
@@ -66,12 +60,6 @@ theorem map_lt_map_iff {x y : R} (h : abv.IsEuclidean) : abv x < abv y ↔ x ≺
 
 attribute [simp] map_lt_map_iff
 
-/- warning: absolute_value.is_euclidean.sub_mod_lt -> AbsoluteValue.IsEuclidean.sub_mod_lt is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : EuclideanDomain.{u1} R] [_inst_2 : OrderedSemiring.{u2} S] {abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2}, (AbsoluteValue.IsEuclidean.{u1, u2} R S _inst_1 _inst_2 abv) -> (forall (a : R) {b : R}, (Ne.{succ u1} R b (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))))))))))) -> (LT.lt.{u2} S (Preorder.toHasLt.{u2} S (PartialOrder.toPreorder.{u2} S (OrderedAddCommMonoid.toPartialOrder.{u2} S (OrderedSemiring.toOrderedAddCommMonoid.{u2} S _inst_2)))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv (HMod.hMod.{u1, u1, u1} R R R (instHMod.{u1} R (EuclideanDomain.hasMod.{u1} R _inst_1)) a b)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv b)))
-but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : EuclideanDomain.{u2} R] [_inst_2 : OrderedSemiring.{u1} S] {abv : AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2}, (AbsoluteValue.IsEuclidean.{u2, u1} R S _inst_1 _inst_2 abv) -> (forall (a : R) {b : R}, (Ne.{succ u2} R b (OfNat.ofNat.{u2} R 0 (Zero.toOfNat0.{u2} R (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) -> (LT.lt.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (Preorder.toLT.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (OrderedSemiring.toPartialOrder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv b)))
-Case conversion may be inaccurate. Consider using '#align absolute_value.is_euclidean.sub_mod_lt AbsoluteValue.IsEuclidean.sub_mod_ltₓ'. -/
 theorem sub_mod_lt (h : abv.IsEuclidean) (a : R) {b : R} (hb : b ≠ 0) : abv (a % b) < abv b :=
   h.map_lt_map_iff.mpr (EuclideanDomain.mod_lt a hb)
 #align absolute_value.is_euclidean.sub_mod_lt AbsoluteValue.IsEuclidean.sub_mod_lt

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

@@ -55,7 +55,7 @@ variable {abv}
 
 /- warning: absolute_value.is_euclidean.map_lt_map_iff -> AbsoluteValue.IsEuclidean.map_lt_map_iff is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : EuclideanDomain.{u1} R] [_inst_2 : OrderedSemiring.{u2} S] {abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2} {x : R} {y : R}, (AbsoluteValue.IsEuclidean.{u1, u2} R S _inst_1 _inst_2 abv) -> (Iff (LT.lt.{u2} S (Preorder.toLT.{u2} S (PartialOrder.toPreorder.{u2} S (OrderedAddCommMonoid.toPartialOrder.{u2} S (OrderedSemiring.toOrderedAddCommMonoid.{u2} S _inst_2)))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv y)) (EuclideanDomain.r.{u1} R _inst_1 x y))
+  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : EuclideanDomain.{u1} R] [_inst_2 : OrderedSemiring.{u2} S] {abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2} {x : R} {y : R}, (AbsoluteValue.IsEuclidean.{u1, u2} R S _inst_1 _inst_2 abv) -> (Iff (LT.lt.{u2} S (Preorder.toHasLt.{u2} S (PartialOrder.toPreorder.{u2} S (OrderedAddCommMonoid.toPartialOrder.{u2} S (OrderedSemiring.toOrderedAddCommMonoid.{u2} S _inst_2)))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv y)) (EuclideanDomain.r.{u1} R _inst_1 x y))
 but is expected to have type
   forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : EuclideanDomain.{u2} R] [_inst_2 : OrderedSemiring.{u1} S] {abv : AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2} {x : R} {y : R}, (AbsoluteValue.IsEuclidean.{u2, u1} R S _inst_1 _inst_2 abv) -> (Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) (Preorder.toLT.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) (OrderedSemiring.toPartialOrder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv y)) (EuclideanDomain.r.{u2} R _inst_1 x y))
 Case conversion may be inaccurate. Consider using '#align absolute_value.is_euclidean.map_lt_map_iff AbsoluteValue.IsEuclidean.map_lt_map_iffₓ'. -/
@@ -68,7 +68,7 @@ attribute [simp] map_lt_map_iff
 
 /- warning: absolute_value.is_euclidean.sub_mod_lt -> AbsoluteValue.IsEuclidean.sub_mod_lt is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : EuclideanDomain.{u1} R] [_inst_2 : OrderedSemiring.{u2} S] {abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2}, (AbsoluteValue.IsEuclidean.{u1, u2} R S _inst_1 _inst_2 abv) -> (forall (a : R) {b : R}, (Ne.{succ u1} R b (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))))))))))) -> (LT.lt.{u2} S (Preorder.toLT.{u2} S (PartialOrder.toPreorder.{u2} S (OrderedAddCommMonoid.toPartialOrder.{u2} S (OrderedSemiring.toOrderedAddCommMonoid.{u2} S _inst_2)))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv (HMod.hMod.{u1, u1, u1} R R R (instHMod.{u1} R (EuclideanDomain.hasMod.{u1} R _inst_1)) a b)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv b)))
+  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : EuclideanDomain.{u1} R] [_inst_2 : OrderedSemiring.{u2} S] {abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2}, (AbsoluteValue.IsEuclidean.{u1, u2} R S _inst_1 _inst_2 abv) -> (forall (a : R) {b : R}, (Ne.{succ u1} R b (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))))))))))) -> (LT.lt.{u2} S (Preorder.toHasLt.{u2} S (PartialOrder.toPreorder.{u2} S (OrderedAddCommMonoid.toPartialOrder.{u2} S (OrderedSemiring.toOrderedAddCommMonoid.{u2} S _inst_2)))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv (HMod.hMod.{u1, u1, u1} R R R (instHMod.{u1} R (EuclideanDomain.hasMod.{u1} R _inst_1)) a b)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv b)))
 but is expected to have type
   forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : EuclideanDomain.{u2} R] [_inst_2 : OrderedSemiring.{u1} S] {abv : AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2}, (AbsoluteValue.IsEuclidean.{u2, u1} R S _inst_1 _inst_2 abv) -> (forall (a : R) {b : R}, (Ne.{succ u2} R b (OfNat.ofNat.{u2} R 0 (Zero.toOfNat0.{u2} R (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) -> (LT.lt.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (Preorder.toLT.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (OrderedSemiring.toPartialOrder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv b)))
 Case conversion may be inaccurate. Consider using '#align absolute_value.is_euclidean.sub_mod_lt AbsoluteValue.IsEuclidean.sub_mod_ltₓ'. -/

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

@@ -57,7 +57,7 @@ variable {abv}
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : EuclideanDomain.{u1} R] [_inst_2 : OrderedSemiring.{u2} S] {abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2} {x : R} {y : R}, (AbsoluteValue.IsEuclidean.{u1, u2} R S _inst_1 _inst_2 abv) -> (Iff (LT.lt.{u2} S (Preorder.toLT.{u2} S (PartialOrder.toPreorder.{u2} S (OrderedAddCommMonoid.toPartialOrder.{u2} S (OrderedSemiring.toOrderedAddCommMonoid.{u2} S _inst_2)))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv y)) (EuclideanDomain.r.{u1} R _inst_1 x y))
 but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : EuclideanDomain.{u2} R] [_inst_2 : OrderedSemiring.{u1} S] {abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2} {x : R} {y : R}, (AbsoluteValue.IsEuclidean.{u2, u1} R S _inst_1 _inst_2 abv) -> (Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) (Preorder.toLT.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) (OrderedSemiring.toPartialOrder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv y)) (EuclideanDomain.r.{u2} R _inst_1 x y))
+  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : EuclideanDomain.{u2} R] [_inst_2 : OrderedSemiring.{u1} S] {abv : AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2} {x : R} {y : R}, (AbsoluteValue.IsEuclidean.{u2, u1} R S _inst_1 _inst_2 abv) -> (Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) (Preorder.toLT.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) (OrderedSemiring.toPartialOrder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv y)) (EuclideanDomain.r.{u2} R _inst_1 x y))
 Case conversion may be inaccurate. Consider using '#align absolute_value.is_euclidean.map_lt_map_iff AbsoluteValue.IsEuclidean.map_lt_map_iffₓ'. -/
 -- Rearrange the parameters to `map_lt_map_iff'` so it elaborates better.
 theorem map_lt_map_iff {x y : R} (h : abv.IsEuclidean) : abv x < abv y ↔ x ≺ y :=
@@ -70,7 +70,7 @@ attribute [simp] map_lt_map_iff
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : EuclideanDomain.{u1} R] [_inst_2 : OrderedSemiring.{u2} S] {abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2}, (AbsoluteValue.IsEuclidean.{u1, u2} R S _inst_1 _inst_2 abv) -> (forall (a : R) {b : R}, (Ne.{succ u1} R b (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))))))))))) -> (LT.lt.{u2} S (Preorder.toLT.{u2} S (PartialOrder.toPreorder.{u2} S (OrderedAddCommMonoid.toPartialOrder.{u2} S (OrderedSemiring.toOrderedAddCommMonoid.{u2} S _inst_2)))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv (HMod.hMod.{u1, u1, u1} R R R (instHMod.{u1} R (EuclideanDomain.hasMod.{u1} R _inst_1)) a b)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv b)))
 but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : EuclideanDomain.{u2} R] [_inst_2 : OrderedSemiring.{u1} S] {abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2}, (AbsoluteValue.IsEuclidean.{u2, u1} R S _inst_1 _inst_2 abv) -> (forall (a : R) {b : R}, (Ne.{succ u2} R b (OfNat.ofNat.{u2} R 0 (Zero.toOfNat0.{u2} R (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) -> (LT.lt.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (Preorder.toLT.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (OrderedSemiring.toPartialOrder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv b)))
+  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : EuclideanDomain.{u2} R] [_inst_2 : OrderedSemiring.{u1} S] {abv : AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2}, (AbsoluteValue.IsEuclidean.{u2, u1} R S _inst_1 _inst_2 abv) -> (forall (a : R) {b : R}, (Ne.{succ u2} R b (OfNat.ofNat.{u2} R 0 (Zero.toOfNat0.{u2} R (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) -> (LT.lt.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (Preorder.toLT.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (OrderedSemiring.toPartialOrder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv b)))
 Case conversion may be inaccurate. Consider using '#align absolute_value.is_euclidean.sub_mod_lt AbsoluteValue.IsEuclidean.sub_mod_ltₓ'. -/
 theorem sub_mod_lt (h : abv.IsEuclidean) (a : R) {b : R} (hb : b ≠ 0) : abv (a % b) < abv b :=
   h.map_lt_map_iff.mpr (EuclideanDomain.mod_lt a hb)

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

@@ -57,7 +57,7 @@ variable {abv}
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : EuclideanDomain.{u1} R] [_inst_2 : OrderedSemiring.{u2} S] {abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2} {x : R} {y : R}, (AbsoluteValue.IsEuclidean.{u1, u2} R S _inst_1 _inst_2 abv) -> (Iff (LT.lt.{u2} S (Preorder.toLT.{u2} S (PartialOrder.toPreorder.{u2} S (OrderedAddCommMonoid.toPartialOrder.{u2} S (OrderedSemiring.toOrderedAddCommMonoid.{u2} S _inst_2)))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv y)) (EuclideanDomain.r.{u1} R _inst_1 x y))
 but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : EuclideanDomain.{u2} R] [_inst_2 : OrderedSemiring.{u1} S] {abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2} {x : R} {y : R}, (AbsoluteValue.IsEuclidean.{u2, u1} R S _inst_1 _inst_2 abv) -> (Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) x) (Preorder.toLT.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) x) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) x) (OrderedSemiring.toPartialOrder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv y)) (EuclideanDomain.r.{u2} R _inst_1 x y))
+  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : EuclideanDomain.{u2} R] [_inst_2 : OrderedSemiring.{u1} S] {abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2} {x : R} {y : R}, (AbsoluteValue.IsEuclidean.{u2, u1} R S _inst_1 _inst_2 abv) -> (Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) (Preorder.toLT.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) (OrderedSemiring.toPartialOrder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv y)) (EuclideanDomain.r.{u2} R _inst_1 x y))
 Case conversion may be inaccurate. Consider using '#align absolute_value.is_euclidean.map_lt_map_iff AbsoluteValue.IsEuclidean.map_lt_map_iffₓ'. -/
 -- Rearrange the parameters to `map_lt_map_iff'` so it elaborates better.
 theorem map_lt_map_iff {x y : R} (h : abv.IsEuclidean) : abv x < abv y ↔ x ≺ y :=
@@ -70,7 +70,7 @@ attribute [simp] map_lt_map_iff
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : EuclideanDomain.{u1} R] [_inst_2 : OrderedSemiring.{u2} S] {abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2}, (AbsoluteValue.IsEuclidean.{u1, u2} R S _inst_1 _inst_2 abv) -> (forall (a : R) {b : R}, (Ne.{succ u1} R b (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))))))))))) -> (LT.lt.{u2} S (Preorder.toLT.{u2} S (PartialOrder.toPreorder.{u2} S (OrderedAddCommMonoid.toPartialOrder.{u2} S (OrderedSemiring.toOrderedAddCommMonoid.{u2} S _inst_2)))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv (HMod.hMod.{u1, u1, u1} R R R (instHMod.{u1} R (EuclideanDomain.hasMod.{u1} R _inst_1)) a b)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv b)))
 but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : EuclideanDomain.{u2} R] [_inst_2 : OrderedSemiring.{u1} S] {abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2}, (AbsoluteValue.IsEuclidean.{u2, u1} R S _inst_1 _inst_2 abv) -> (forall (a : R) {b : R}, (Ne.{succ u2} R b (OfNat.ofNat.{u2} R 0 (Zero.toOfNat0.{u2} R (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) -> (LT.lt.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (Preorder.toLT.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (OrderedSemiring.toPartialOrder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv b)))
+  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : EuclideanDomain.{u2} R] [_inst_2 : OrderedSemiring.{u1} S] {abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2}, (AbsoluteValue.IsEuclidean.{u2, u1} R S _inst_1 _inst_2 abv) -> (forall (a : R) {b : R}, (Ne.{succ u2} R b (OfNat.ofNat.{u2} R 0 (Zero.toOfNat0.{u2} R (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) -> (LT.lt.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (Preorder.toLT.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (OrderedSemiring.toPartialOrder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.99 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv b)))
 Case conversion may be inaccurate. Consider using '#align absolute_value.is_euclidean.sub_mod_lt AbsoluteValue.IsEuclidean.sub_mod_ltₓ'. -/
 theorem sub_mod_lt (h : abv.IsEuclidean) (a : R) {b : R} (hb : b ≠ 0) : abv (a % b) < abv b :=
   h.map_lt_map_iff.mpr (EuclideanDomain.mod_lt a hb)

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

@@ -57,7 +57,7 @@ variable {abv}
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : EuclideanDomain.{u1} R] [_inst_2 : OrderedSemiring.{u2} S] {abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2} {x : R} {y : R}, (AbsoluteValue.IsEuclidean.{u1, u2} R S _inst_1 _inst_2 abv) -> (Iff (LT.lt.{u2} S (Preorder.toLT.{u2} S (PartialOrder.toPreorder.{u2} S (OrderedAddCommMonoid.toPartialOrder.{u2} S (OrderedSemiring.toOrderedAddCommMonoid.{u2} S _inst_2)))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv y)) (EuclideanDomain.r.{u1} R _inst_1 x y))
 but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : EuclideanDomain.{u2} R] [_inst_2 : OrderedSemiring.{u1} S] {abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2} {x : R} {y : R}, (AbsoluteValue.IsEuclidean.{u2, u1} R S _inst_1 _inst_2 abv) -> (Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) x) (Preorder.toLT.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) x) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) x) (OrderedSemiring.toPartialOrder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv y)) (EuclideanDomain.r.{u2} R _inst_1 x y))
+  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : EuclideanDomain.{u2} R] [_inst_2 : OrderedSemiring.{u1} S] {abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2} {x : R} {y : R}, (AbsoluteValue.IsEuclidean.{u2, u1} R S _inst_1 _inst_2 abv) -> (Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) x) (Preorder.toLT.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) x) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) x) (OrderedSemiring.toPartialOrder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv y)) (EuclideanDomain.r.{u2} R _inst_1 x y))
 Case conversion may be inaccurate. Consider using '#align absolute_value.is_euclidean.map_lt_map_iff AbsoluteValue.IsEuclidean.map_lt_map_iffₓ'. -/
 -- Rearrange the parameters to `map_lt_map_iff'` so it elaborates better.
 theorem map_lt_map_iff {x y : R} (h : abv.IsEuclidean) : abv x < abv y ↔ x ≺ y :=
@@ -70,7 +70,7 @@ attribute [simp] map_lt_map_iff
 lean 3 declaration is
   forall {R : Type.{u1}} {S : Type.{u2}} [_inst_1 : EuclideanDomain.{u1} R] [_inst_2 : OrderedSemiring.{u2} S] {abv : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2}, (AbsoluteValue.IsEuclidean.{u1, u2} R S _inst_1 _inst_2 abv) -> (forall (a : R) {b : R}, (Ne.{succ u1} R b (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))))))))))) -> (LT.lt.{u2} S (Preorder.toLT.{u2} S (PartialOrder.toPreorder.{u2} S (OrderedAddCommMonoid.toPartialOrder.{u2} S (OrderedSemiring.toOrderedAddCommMonoid.{u2} S _inst_2)))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv (HMod.hMod.{u1, u1, u1} R R R (instHMod.{u1} R (EuclideanDomain.hasMod.{u1} R _inst_1)) a b)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) (fun (f : AbsoluteValue.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) => R -> S) (AbsoluteValue.hasCoeToFun.{u1, u2} R S (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R (EuclideanDomain.toCommRing.{u1} R _inst_1))) _inst_2) abv b)))
 but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : EuclideanDomain.{u2} R] [_inst_2 : OrderedSemiring.{u1} S] {abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2}, (AbsoluteValue.IsEuclidean.{u2, u1} R S _inst_1 _inst_2 abv) -> (forall (a : R) {b : R}, (Ne.{succ u2} R b (OfNat.ofNat.{u2} R 0 (Zero.toOfNat0.{u2} R (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) -> (LT.lt.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (Preorder.toLT.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (OrderedSemiring.toPartialOrder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.96 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv b)))
+  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : EuclideanDomain.{u2} R] [_inst_2 : OrderedSemiring.{u1} S] {abv : AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2}, (AbsoluteValue.IsEuclidean.{u2, u1} R S _inst_1 _inst_2 abv) -> (forall (a : R) {b : R}, (Ne.{succ u2} R b (OfNat.ofNat.{u2} R 0 (Zero.toOfNat0.{u2} R (CommMonoidWithZero.toZero.{u2} R (CommSemiring.toCommMonoidWithZero.{u2} R (CommRing.toCommSemiring.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) -> (LT.lt.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (Preorder.toLT.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (OrderedSemiring.toPartialOrder.{u1} ((fun (x._@.Mathlib.Algebra.Order.Hom.Basic._hyg.98 : R) => S) (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv (HMod.hMod.{u2, u2, u2} R R R (instHMod.{u2} R (EuclideanDomain.instMod.{u2} R _inst_1)) a b)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AbsoluteValue.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _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 (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2) R S (Distrib.toAdd.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))))))) (Distrib.toAdd.{u1} S (NonUnitalNonAssocSemiring.toDistrib.{u1} S (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} S (Semiring.toNonAssocSemiring.{u1} S (OrderedSemiring.toSemiring.{u1} S _inst_2))))) (Preorder.toLE.{u1} S (PartialOrder.toPreorder.{u1} S (OrderedSemiring.toPartialOrder.{u1} S _inst_2))) (AbsoluteValue.subadditiveHomClass.{u2, u1} R S (Ring.toSemiring.{u2} R (CommRing.toRing.{u2} R (EuclideanDomain.toCommRing.{u2} R _inst_1))) _inst_2)) abv b)))
 Case conversion may be inaccurate. Consider using '#align absolute_value.is_euclidean.sub_mod_lt AbsoluteValue.IsEuclidean.sub_mod_ltₓ'. -/
 theorem sub_mod_lt (h : abv.IsEuclidean) (a : R) {b : R} (hb : b ≠ 0) : abv (a % b) < abv b :=
   h.map_lt_map_iff.mpr (EuclideanDomain.mod_lt a hb)

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

Empty lines were removed by executing the following Python script twice

import os
import re


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

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

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

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

@@ -31,7 +31,6 @@ namespace AbsoluteValue
 section OrderedSemiring
 
 variable {R S : Type*} [EuclideanDomain R] [OrderedSemiring S]
-
 variable (abv : AbsoluteValue R S)
 
 /-- An absolute value `abv : R → S` is Euclidean if it is compatible with the

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

This has nice performance benefits.

@@ -30,7 +30,7 @@ namespace AbsoluteValue
 
 section OrderedSemiring
 
-variable {R S : Type _} [EuclideanDomain R] [OrderedSemiring S]
+variable {R S : Type*} [EuclideanDomain R] [OrderedSemiring S]
 
 variable (abv : AbsoluteValue R S)
 

• depends on: #5966

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

@@ -2,15 +2,12 @@
 Copyright (c) 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 algebra.order.euclidean_absolute_value
-! leanprover-community/mathlib commit 422e70f7ce183d2900c586a8cda8381e788a0c62
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Order.AbsoluteValue
 import Mathlib.Algebra.EuclideanDomain.Instances
 
+#align_import algebra.order.euclidean_absolute_value from "leanprover-community/mathlib"@"422e70f7ce183d2900c586a8cda8381e788a0c62"
+
 /-!
 # Euclidean absolute values
 

Small PR. Nothing super special here, although I did have a question. On line 74, is it within style guidelines to use @ to make the parameters explicit? Thanks!

Co-authored-by: z <32079362+xoers@users.noreply.github.com> Co-authored-by: Chris Hughes <33847686+ChrisHughes24@users.noreply.github.com>