algebra.order.sub.basic | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

10b4e499

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

448144f7

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
 -/
 import Order.Hom.Basic
-import Algebra.Hom.Equiv.Basic
+import Algebra.Group.Equiv.Basic
 import Algebra.Ring.Basic
 import Algebra.Order.Sub.Defs

448144f7

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,10 +3,10 @@ Copyright (c) 2021 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
 -/
-import Mathbin.Order.Hom.Basic
-import Mathbin.Algebra.Hom.Equiv.Basic
-import Mathbin.Algebra.Ring.Basic
-import Mathbin.Algebra.Order.Sub.Defs
+import Order.Hom.Basic
+import Algebra.Hom.Equiv.Basic
+import Algebra.Ring.Basic
+import Algebra.Order.Sub.Defs
 
 #align_import algebra.order.sub.basic from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"

448144f7

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2021 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
-
-! This file was ported from Lean 3 source module algebra.order.sub.basic
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Hom.Basic
 import Mathbin.Algebra.Hom.Equiv.Basic
 import Mathbin.Algebra.Ring.Basic
 import Mathbin.Algebra.Order.Sub.Defs
 
+#align_import algebra.order.sub.basic from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"
+
 /-!
 # Additional results about ordered Subtraction

448144f7

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -35,18 +35,23 @@ theorem AddHom.le_map_tsub [Preorder β] [Add β] [Sub β] [OrderedSub β] (f :
 #align add_hom.le_map_tsub AddHom.le_map_tsub
 -/
 
+#print le_mul_tsub /-
 theorem le_mul_tsub {R : Type _} [Distrib R] [Preorder R] [Sub R] [OrderedSub R]
     [CovariantClass R R (· * ·) (· ≤ ·)] {a b c : R} : a * b - a * c ≤ a * (b - c) :=
   (AddHom.mulLeft a).le_map_tsub (monotone_id.const_mul' a) _ _
 #align le_mul_tsub le_mul_tsub
+-/
 
+#print le_tsub_mul /-
 theorem le_tsub_mul {R : Type _} [CommSemiring R] [Preorder R] [Sub R] [OrderedSub R]
     [CovariantClass R R (· * ·) (· ≤ ·)] {a b c : R} : a * c - b * c ≤ (a - b) * c := by
   simpa only [mul_comm _ c] using le_mul_tsub
 #align le_tsub_mul le_tsub_mul
+-/
 
 end Add
 
+#print OrderIso.map_tsub /-
 /-- An order isomorphism between types with ordered subtraction preserves subtraction provided that
 it preserves addition. -/
 theorem OrderIso.map_tsub {M N : Type _} [Preorder M] [Add M] [Sub M] [OrderedSub M]
@@ -58,6 +63,7 @@ theorem OrderIso.map_tsub {M N : Type _} [Preorder M] [Add M] [Sub M] [OrderedSu
   suffices e (e.symm (e a) - e.symm (e b)) ≤ e (e.symm (e a - e b)) by simpa
   exact e.monotone (e_add.symm.to_add_hom.le_map_tsub e.symm.monotone _ _)
 #align order_iso.map_tsub OrderIso.map_tsub
+-/
 
 /-! ### Preorder -/
 
@@ -68,10 +74,12 @@ variable [Preorder α]
 
 variable [AddCommMonoid α] [Sub α] [OrderedSub α] {a b c d : α}
 
+#print AddMonoidHom.le_map_tsub /-
 theorem AddMonoidHom.le_map_tsub [Preorder β] [AddCommMonoid β] [Sub β] [OrderedSub β] (f : α →+ β)
     (hf : Monotone f) (a b : α) : f a - f b ≤ f (a - b) :=
   f.toAddHom.le_map_tsub hf a b
 #align add_monoid_hom.le_map_tsub AddMonoidHom.le_map_tsub
+-/
 
 end Preorder

448144f7

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -28,10 +28,12 @@ section Add
 
 variable [Preorder α] [Add α] [Sub α] [OrderedSub α] {a b c d : α}
 
+#print AddHom.le_map_tsub /-
 theorem AddHom.le_map_tsub [Preorder β] [Add β] [Sub β] [OrderedSub β] (f : AddHom α β)
     (hf : Monotone f) (a b : α) : f a - f b ≤ f (a - b) := by rw [tsub_le_iff_right, ← f.map_add];
   exact hf le_tsub_add
 #align add_hom.le_map_tsub AddHom.le_map_tsub
+-/
 
 theorem le_mul_tsub {R : Type _} [Distrib R] [Preorder R] [Sub R] [OrderedSub R]
     [CovariantClass R R (· * ·) (· ≤ ·)] {a b c : R} : a * b - a * c ≤ a * (b - c) :=

448144f7

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -28,31 +28,16 @@ section Add
 
 variable [Preorder α] [Add α] [Sub α] [OrderedSub α] {a b c d : α}
 
-/- warning: add_hom.le_map_tsub -> AddHom.le_map_tsub is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align add_hom.le_map_tsub AddHom.le_map_tsubₓ'. -/
 theorem AddHom.le_map_tsub [Preorder β] [Add β] [Sub β] [OrderedSub β] (f : AddHom α β)
     (hf : Monotone f) (a b : α) : f a - f b ≤ f (a - b) := by rw [tsub_le_iff_right, ← f.map_add];
   exact hf le_tsub_add
 #align add_hom.le_map_tsub AddHom.le_map_tsub
 
-/- warning: le_mul_tsub -> le_mul_tsub is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_5 : Distrib.{u1} R] [_inst_6 : Preorder.{u1} R] [_inst_7 : Sub.{u1} R] [_inst_8 : OrderedSub.{u1} R (Preorder.toHasLe.{u1} R _inst_6) (Distrib.toHasAdd.{u1} R _inst_5) _inst_7] [_inst_9 : CovariantClass.{u1, u1} R R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R _inst_5))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_6))] {a : R} {b : R} {c : R}, LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_6) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R _inst_5)) a b) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R _inst_5)) a c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R _inst_5)) a (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) b c))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_5 : Distrib.{u1} R] [_inst_6 : Preorder.{u1} R] [_inst_7 : Sub.{u1} R] [_inst_8 : OrderedSub.{u1} R (Preorder.toLE.{u1} R _inst_6) (Distrib.toAdd.{u1} R _inst_5) _inst_7] [_inst_9 : CovariantClass.{u1, u1} R R (fun (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.174 : R) (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.176 : R) => HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toMul.{u1} R _inst_5)) x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.174 x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.176) (fun (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.189 : R) (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.191 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.189 x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.191)] {a : R} {b : R} {c : R}, LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toMul.{u1} R _inst_5)) a b) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toMul.{u1} R _inst_5)) a c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toMul.{u1} R _inst_5)) a (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) b c))
-Case conversion may be inaccurate. Consider using '#align le_mul_tsub le_mul_tsubₓ'. -/
 theorem le_mul_tsub {R : Type _} [Distrib R] [Preorder R] [Sub R] [OrderedSub R]
     [CovariantClass R R (· * ·) (· ≤ ·)] {a b c : R} : a * b - a * c ≤ a * (b - c) :=
   (AddHom.mulLeft a).le_map_tsub (monotone_id.const_mul' a) _ _
 #align le_mul_tsub le_mul_tsub
 
-/- warning: le_tsub_mul -> le_tsub_mul is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_5 : CommSemiring.{u1} R] [_inst_6 : Preorder.{u1} R] [_inst_7 : Sub.{u1} R] [_inst_8 : OrderedSub.{u1} R (Preorder.toHasLe.{u1} R _inst_6) (Distrib.toHasAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) _inst_7] [_inst_9 : CovariantClass.{u1, u1} R R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_6))] {a : R} {b : R} {c : R}, LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_6) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5)))))) a c) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5)))))) b c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5)))))) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) a b) c)
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_5 : CommSemiring.{u1} R] [_inst_6 : Preorder.{u1} R] [_inst_7 : Sub.{u1} R] [_inst_8 : OrderedSub.{u1} R (Preorder.toLE.{u1} R _inst_6) (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) _inst_7] [_inst_9 : CovariantClass.{u1, u1} R R (fun (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.270 : R) (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.272 : R) => HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.270 x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.272) (fun (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.285 : R) (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.287 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.285 x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.287)] {a : R} {b : R} {c : R}, LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) a c) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) b c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) a b) c)
-Case conversion may be inaccurate. Consider using '#align le_tsub_mul le_tsub_mulₓ'. -/
 theorem le_tsub_mul {R : Type _} [CommSemiring R] [Preorder R] [Sub R] [OrderedSub R]
     [CovariantClass R R (· * ·) (· ≤ ·)] {a b c : R} : a * c - b * c ≤ (a - b) * c := by
   simpa only [mul_comm _ c] using le_mul_tsub
@@ -60,9 +45,6 @@ theorem le_tsub_mul {R : Type _} [CommSemiring R] [Preorder R] [Sub R] [OrderedS
 
 end Add
 
-/- warning: order_iso.map_tsub -> OrderIso.map_tsub is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align order_iso.map_tsub OrderIso.map_tsubₓ'. -/
 /-- An order isomorphism between types with ordered subtraction preserves subtraction provided that
 it preserves addition. -/
 theorem OrderIso.map_tsub {M N : Type _} [Preorder M] [Add M] [Sub M] [OrderedSub M]
@@ -84,9 +66,6 @@ variable [Preorder α]
 
 variable [AddCommMonoid α] [Sub α] [OrderedSub α] {a b c d : α}
 
-/- warning: add_monoid_hom.le_map_tsub -> AddMonoidHom.le_map_tsub is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align add_monoid_hom.le_map_tsub AddMonoidHom.le_map_tsubₓ'. -/
 theorem AddMonoidHom.le_map_tsub [Preorder β] [AddCommMonoid β] [Sub β] [OrderedSub β] (f : α →+ β)
     (hf : Monotone f) (a b : α) : f a - f b ≤ f (a - b) :=
   f.toAddHom.le_map_tsub hf a b

448144f7

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -32,9 +32,7 @@ variable [Preorder α] [Add α] [Sub α] [OrderedSub α] {a b c d : α}
 <too large>
 Case conversion may be inaccurate. Consider using '#align add_hom.le_map_tsub AddHom.le_map_tsubₓ'. -/
 theorem AddHom.le_map_tsub [Preorder β] [Add β] [Sub β] [OrderedSub β] (f : AddHom α β)
-    (hf : Monotone f) (a b : α) : f a - f b ≤ f (a - b) :=
-  by
-  rw [tsub_le_iff_right, ← f.map_add]
+    (hf : Monotone f) (a b : α) : f a - f b ≤ f (a - b) := by rw [tsub_le_iff_right, ← f.map_add];
   exact hf le_tsub_add
 #align add_hom.le_map_tsub AddHom.le_map_tsub

448144f7

bump to nightly-2023-05-28-03

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

6c6011cf

Diff

@@ -29,10 +29,7 @@ section Add
 variable [Preorder α] [Add α] [Sub α] [OrderedSub α] {a b c d : α}
 
 /- warning: add_hom.le_map_tsub -> AddHom.le_map_tsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : Preorder.{u2} β] [_inst_6 : Add.{u2} β] [_inst_7 : Sub.{u2} β] [_inst_8 : OrderedSub.{u2} β (Preorder.toHasLe.{u2} β _inst_5) _inst_6 _inst_7] (f : AddHom.{u1, u2} α β _inst_2 _inst_6), (Monotone.{u1, u2} α β _inst_1 _inst_5 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddHom.{u1, u2} α β _inst_2 _inst_6) (fun (_x : AddHom.{u1, u2} α β _inst_2 _inst_6) => α -> β) (AddHom.hasCoeToFun.{u1, u2} α β _inst_2 _inst_6) f)) -> (forall (a : α) (b : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_5) (HSub.hSub.{u2, u2, u2} β β β (instHSub.{u2} β _inst_7) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddHom.{u1, u2} α β _inst_2 _inst_6) (fun (_x : AddHom.{u1, u2} α β _inst_2 _inst_6) => α -> β) (AddHom.hasCoeToFun.{u1, u2} α β _inst_2 _inst_6) f a) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddHom.{u1, u2} α β _inst_2 _inst_6) (fun (_x : AddHom.{u1, u2} α β _inst_2 _inst_6) => α -> β) (AddHom.hasCoeToFun.{u1, u2} α β _inst_2 _inst_6) f b)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddHom.{u1, u2} α β _inst_2 _inst_6) (fun (_x : AddHom.{u1, u2} α β _inst_2 _inst_6) => α -> β) (AddHom.hasCoeToFun.{u1, u2} α β _inst_2 _inst_6) f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : Preorder.{u2} β] [_inst_6 : Add.{u2} β] [_inst_7 : Sub.{u2} β] [_inst_8 : OrderedSub.{u2} β (Preorder.toLE.{u2} β _inst_5) _inst_6 _inst_7] (f : AddHom.{u1, u2} α β _inst_2 _inst_6), (Monotone.{u1, u2} α β _inst_1 _inst_5 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddHom.{u1, u2} α β _inst_2 _inst_6) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddHom.{u1, u2} α β _inst_2 _inst_6) α β _inst_2 _inst_6 (AddHom.addHomClass.{u1, u2} α β _inst_2 _inst_6)) f)) -> (forall (a : α) (b : α), LE.le.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) (Preorder.toLE.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) _inst_5) (HSub.hSub.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) b) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) (instHSub.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) _inst_7) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddHom.{u1, u2} α β _inst_2 _inst_6) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddHom.{u1, u2} α β _inst_2 _inst_6) α β _inst_2 _inst_6 (AddHom.addHomClass.{u1, u2} α β _inst_2 _inst_6)) f a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddHom.{u1, u2} α β _inst_2 _inst_6) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddHom.{u1, u2} α β _inst_2 _inst_6) α β _inst_2 _inst_6 (AddHom.addHomClass.{u1, u2} α β _inst_2 _inst_6)) f b)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddHom.{u1, u2} α β _inst_2 _inst_6) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddHom.{u1, u2} α β _inst_2 _inst_6) α β _inst_2 _inst_6 (AddHom.addHomClass.{u1, u2} α β _inst_2 _inst_6)) f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)))
+<too large>
 Case conversion may be inaccurate. Consider using '#align add_hom.le_map_tsub AddHom.le_map_tsubₓ'. -/
 theorem AddHom.le_map_tsub [Preorder β] [Add β] [Sub β] [OrderedSub β] (f : AddHom α β)
     (hf : Monotone f) (a b : α) : f a - f b ≤ f (a - b) :=
@@ -66,10 +63,7 @@ theorem le_tsub_mul {R : Type _} [CommSemiring R] [Preorder R] [Sub R] [OrderedS
 end Add
 
 /- warning: order_iso.map_tsub -> OrderIso.map_tsub is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Preorder.{u1} M] [_inst_2 : Add.{u1} M] [_inst_3 : Sub.{u1} M] [_inst_4 : OrderedSub.{u1} M (Preorder.toHasLe.{u1} M _inst_1) _inst_2 _inst_3] [_inst_5 : PartialOrder.{u2} N] [_inst_6 : Add.{u2} N] [_inst_7 : Sub.{u2} N] [_inst_8 : OrderedSub.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)) _inst_6 _inst_7] (e : OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))), (forall (a : M) (b : M), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M _inst_2) a b)) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N _inst_6) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e a) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e b))) -> (forall (a : M) (b : M), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e (HSub.hSub.{u1, u1, u1} M M M (instHSub.{u1} M _inst_3) a b)) (HSub.hSub.{u2, u2, u2} N N N (instHSub.{u2} N _inst_7) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e a) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e b)))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Preorder.{u2} M] [_inst_2 : Add.{u2} M] [_inst_3 : Sub.{u2} M] [_inst_4 : OrderedSub.{u2} M (Preorder.toLE.{u2} M _inst_1) _inst_2 _inst_3] [_inst_5 : PartialOrder.{u1} N] [_inst_6 : Add.{u1} N] [_inst_7 : Sub.{u1} N] [_inst_8 : OrderedSub.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) _inst_6 _inst_7] (e : OrderIso.{u2, u1} M N (Preorder.toLE.{u2} M _inst_1) (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5))), (forall (a : M) (b : M), Eq.{succ u1} N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) e (HAdd.hAdd.{u2, u2, u2} M M M (instHAdd.{u2} M _inst_2) a b)) (HAdd.hAdd.{u1, u1, u1} N N N (instHAdd.{u1} N _inst_6) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) e a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) e b))) -> (forall (a : M) (b : M), Eq.{succ u1} N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) e (HSub.hSub.{u2, u2, u2} M M M (instHSub.{u2} M _inst_3) a b)) (HSub.hSub.{u1, u1, u1} N N N (instHSub.{u1} N _inst_7) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) e a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) e b)))
+<too large>
 Case conversion may be inaccurate. Consider using '#align order_iso.map_tsub OrderIso.map_tsubₓ'. -/
 /-- An order isomorphism between types with ordered subtraction preserves subtraction provided that
 it preserves addition. -/
@@ -93,10 +87,7 @@ variable [Preorder α]
 variable [AddCommMonoid α] [Sub α] [OrderedSub α] {a b c d : α}
 
 /- warning: add_monoid_hom.le_map_tsub -> AddMonoidHom.le_map_tsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] [_inst_5 : Preorder.{u2} β] [_inst_6 : AddCommMonoid.{u2} β] [_inst_7 : Sub.{u2} β] [_inst_8 : OrderedSub.{u2} β (Preorder.toHasLe.{u2} β _inst_5) (AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) _inst_7] (f : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))), (Monotone.{u1, u2} α β _inst_1 _inst_5 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (fun (_x : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) => α -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) f)) -> (forall (a : α) (b : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_5) (HSub.hSub.{u2, u2, u2} β β β (instHSub.{u2} β _inst_7) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (fun (_x : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) => α -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) f a) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (fun (_x : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) => α -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) f b)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (fun (_x : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) => α -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] [_inst_5 : Preorder.{u2} β] [_inst_6 : AddCommMonoid.{u2} β] [_inst_7 : Sub.{u2} β] [_inst_8 : OrderedSub.{u2} β (Preorder.toLE.{u2} β _inst_5) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) _inst_7] (f : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))), (Monotone.{u1, u2} α β _inst_1 _inst_5 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6)) (AddMonoidHom.addMonoidHomClass.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))))) f)) -> (forall (a : α) (b : α), LE.le.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) (Preorder.toLE.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) _inst_5) (HSub.hSub.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) b) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) (instHSub.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) _inst_7) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6)) (AddMonoidHom.addMonoidHomClass.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))))) f a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6)) (AddMonoidHom.addMonoidHomClass.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))))) f b)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6)) (AddMonoidHom.addMonoidHomClass.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))))) f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)))
+<too large>
 Case conversion may be inaccurate. Consider using '#align add_monoid_hom.le_map_tsub AddMonoidHom.le_map_tsubₓ'. -/
 theorem AddMonoidHom.le_map_tsub [Preorder β] [AddCommMonoid β] [Sub β] [OrderedSub β] (f : α →+ β)
     (hf : Monotone f) (a b : α) : f a - f b ≤ f (a - b) :=

448144f7

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -69,7 +69,7 @@ end Add
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Preorder.{u1} M] [_inst_2 : Add.{u1} M] [_inst_3 : Sub.{u1} M] [_inst_4 : OrderedSub.{u1} M (Preorder.toHasLe.{u1} M _inst_1) _inst_2 _inst_3] [_inst_5 : PartialOrder.{u2} N] [_inst_6 : Add.{u2} N] [_inst_7 : Sub.{u2} N] [_inst_8 : OrderedSub.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)) _inst_6 _inst_7] (e : OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))), (forall (a : M) (b : M), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M _inst_2) a b)) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N _inst_6) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e a) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e b))) -> (forall (a : M) (b : M), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e (HSub.hSub.{u1, u1, u1} M M M (instHSub.{u1} M _inst_3) a b)) (HSub.hSub.{u2, u2, u2} N N N (instHSub.{u2} N _inst_7) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e a) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e b)))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Preorder.{u2} M] [_inst_2 : Add.{u2} M] [_inst_3 : Sub.{u2} M] [_inst_4 : OrderedSub.{u2} M (Preorder.toLE.{u2} M _inst_1) _inst_2 _inst_3] [_inst_5 : PartialOrder.{u1} N] [_inst_6 : Add.{u1} N] [_inst_7 : Sub.{u1} N] [_inst_8 : OrderedSub.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) _inst_6 _inst_7] (e : OrderIso.{u2, u1} M N (Preorder.toLE.{u2} M _inst_1) (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5))), (forall (a : M) (b : M), Eq.{succ u1} N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e (HAdd.hAdd.{u2, u2, u2} M M M (instHAdd.{u2} M _inst_2) a b)) (HAdd.hAdd.{u1, u1, u1} N N N (instHAdd.{u1} N _inst_6) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e b))) -> (forall (a : M) (b : M), Eq.{succ u1} N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e (HSub.hSub.{u2, u2, u2} M M M (instHSub.{u2} M _inst_3) a b)) (HSub.hSub.{u1, u1, u1} N N N (instHSub.{u1} N _inst_7) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e b)))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Preorder.{u2} M] [_inst_2 : Add.{u2} M] [_inst_3 : Sub.{u2} M] [_inst_4 : OrderedSub.{u2} M (Preorder.toLE.{u2} M _inst_1) _inst_2 _inst_3] [_inst_5 : PartialOrder.{u1} N] [_inst_6 : Add.{u1} N] [_inst_7 : Sub.{u1} N] [_inst_8 : OrderedSub.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) _inst_6 _inst_7] (e : OrderIso.{u2, u1} M N (Preorder.toLE.{u2} M _inst_1) (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5))), (forall (a : M) (b : M), Eq.{succ u1} N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) e (HAdd.hAdd.{u2, u2, u2} M M M (instHAdd.{u2} M _inst_2) a b)) (HAdd.hAdd.{u1, u1, u1} N N N (instHAdd.{u1} N _inst_6) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) e a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) e b))) -> (forall (a : M) (b : M), Eq.{succ u1} N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) e (HSub.hSub.{u2, u2, u2} M M M (instHSub.{u2} M _inst_3) a b)) (HSub.hSub.{u1, u1, u1} N N N (instHSub.{u1} N _inst_7) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) e a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) e b)))
 Case conversion may be inaccurate. Consider using '#align order_iso.map_tsub OrderIso.map_tsubₓ'. -/
 /-- An order isomorphism between types with ordered subtraction preserves subtraction provided that
 it preserves addition. -/

448144f7

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -28,18 +28,22 @@ section Add
 
 variable [Preorder α] [Add α] [Sub α] [OrderedSub α] {a b c d : α}
 
-#print AddHom.le_map_tsub /-
+/- warning: add_hom.le_map_tsub -> AddHom.le_map_tsub is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : Preorder.{u2} β] [_inst_6 : Add.{u2} β] [_inst_7 : Sub.{u2} β] [_inst_8 : OrderedSub.{u2} β (Preorder.toHasLe.{u2} β _inst_5) _inst_6 _inst_7] (f : AddHom.{u1, u2} α β _inst_2 _inst_6), (Monotone.{u1, u2} α β _inst_1 _inst_5 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddHom.{u1, u2} α β _inst_2 _inst_6) (fun (_x : AddHom.{u1, u2} α β _inst_2 _inst_6) => α -> β) (AddHom.hasCoeToFun.{u1, u2} α β _inst_2 _inst_6) f)) -> (forall (a : α) (b : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_5) (HSub.hSub.{u2, u2, u2} β β β (instHSub.{u2} β _inst_7) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddHom.{u1, u2} α β _inst_2 _inst_6) (fun (_x : AddHom.{u1, u2} α β _inst_2 _inst_6) => α -> β) (AddHom.hasCoeToFun.{u1, u2} α β _inst_2 _inst_6) f a) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddHom.{u1, u2} α β _inst_2 _inst_6) (fun (_x : AddHom.{u1, u2} α β _inst_2 _inst_6) => α -> β) (AddHom.hasCoeToFun.{u1, u2} α β _inst_2 _inst_6) f b)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddHom.{u1, u2} α β _inst_2 _inst_6) (fun (_x : AddHom.{u1, u2} α β _inst_2 _inst_6) => α -> β) (AddHom.hasCoeToFun.{u1, u2} α β _inst_2 _inst_6) f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : Preorder.{u2} β] [_inst_6 : Add.{u2} β] [_inst_7 : Sub.{u2} β] [_inst_8 : OrderedSub.{u2} β (Preorder.toLE.{u2} β _inst_5) _inst_6 _inst_7] (f : AddHom.{u1, u2} α β _inst_2 _inst_6), (Monotone.{u1, u2} α β _inst_1 _inst_5 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddHom.{u1, u2} α β _inst_2 _inst_6) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddHom.{u1, u2} α β _inst_2 _inst_6) α β _inst_2 _inst_6 (AddHom.addHomClass.{u1, u2} α β _inst_2 _inst_6)) f)) -> (forall (a : α) (b : α), LE.le.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) (Preorder.toLE.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) _inst_5) (HSub.hSub.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) b) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) (instHSub.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) _inst_7) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddHom.{u1, u2} α β _inst_2 _inst_6) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddHom.{u1, u2} α β _inst_2 _inst_6) α β _inst_2 _inst_6 (AddHom.addHomClass.{u1, u2} α β _inst_2 _inst_6)) f a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddHom.{u1, u2} α β _inst_2 _inst_6) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddHom.{u1, u2} α β _inst_2 _inst_6) α β _inst_2 _inst_6 (AddHom.addHomClass.{u1, u2} α β _inst_2 _inst_6)) f b)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddHom.{u1, u2} α β _inst_2 _inst_6) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddHom.{u1, u2} α β _inst_2 _inst_6) α β _inst_2 _inst_6 (AddHom.addHomClass.{u1, u2} α β _inst_2 _inst_6)) f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)))
+Case conversion may be inaccurate. Consider using '#align add_hom.le_map_tsub AddHom.le_map_tsubₓ'. -/
 theorem AddHom.le_map_tsub [Preorder β] [Add β] [Sub β] [OrderedSub β] (f : AddHom α β)
     (hf : Monotone f) (a b : α) : f a - f b ≤ f (a - b) :=
   by
   rw [tsub_le_iff_right, ← f.map_add]
   exact hf le_tsub_add
 #align add_hom.le_map_tsub AddHom.le_map_tsub
--/
 
 /- warning: le_mul_tsub -> le_mul_tsub is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_5 : Distrib.{u1} R] [_inst_6 : Preorder.{u1} R] [_inst_7 : Sub.{u1} R] [_inst_8 : OrderedSub.{u1} R (Preorder.toLE.{u1} R _inst_6) (Distrib.toHasAdd.{u1} R _inst_5) _inst_7] [_inst_9 : CovariantClass.{u1, u1} R R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R _inst_5))) (LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6))] {a : R} {b : R} {c : R}, LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R _inst_5)) a b) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R _inst_5)) a c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R _inst_5)) a (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) b c))
+  forall {R : Type.{u1}} [_inst_5 : Distrib.{u1} R] [_inst_6 : Preorder.{u1} R] [_inst_7 : Sub.{u1} R] [_inst_8 : OrderedSub.{u1} R (Preorder.toHasLe.{u1} R _inst_6) (Distrib.toHasAdd.{u1} R _inst_5) _inst_7] [_inst_9 : CovariantClass.{u1, u1} R R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R _inst_5))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_6))] {a : R} {b : R} {c : R}, LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_6) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R _inst_5)) a b) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R _inst_5)) a c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R _inst_5)) a (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) b c))
 but is expected to have type
   forall {R : Type.{u1}} [_inst_5 : Distrib.{u1} R] [_inst_6 : Preorder.{u1} R] [_inst_7 : Sub.{u1} R] [_inst_8 : OrderedSub.{u1} R (Preorder.toLE.{u1} R _inst_6) (Distrib.toAdd.{u1} R _inst_5) _inst_7] [_inst_9 : CovariantClass.{u1, u1} R R (fun (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.174 : R) (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.176 : R) => HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toMul.{u1} R _inst_5)) x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.174 x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.176) (fun (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.189 : R) (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.191 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.189 x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.191)] {a : R} {b : R} {c : R}, LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toMul.{u1} R _inst_5)) a b) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toMul.{u1} R _inst_5)) a c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toMul.{u1} R _inst_5)) a (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) b c))
 Case conversion may be inaccurate. Consider using '#align le_mul_tsub le_mul_tsubₓ'. -/
@@ -50,7 +54,7 @@ theorem le_mul_tsub {R : Type _} [Distrib R] [Preorder R] [Sub R] [OrderedSub R]
 
 /- warning: le_tsub_mul -> le_tsub_mul is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_5 : CommSemiring.{u1} R] [_inst_6 : Preorder.{u1} R] [_inst_7 : Sub.{u1} R] [_inst_8 : OrderedSub.{u1} R (Preorder.toLE.{u1} R _inst_6) (Distrib.toHasAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) _inst_7] [_inst_9 : CovariantClass.{u1, u1} R R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))))) (LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6))] {a : R} {b : R} {c : R}, LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5)))))) a c) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5)))))) b c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5)))))) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) a b) c)
+  forall {R : Type.{u1}} [_inst_5 : CommSemiring.{u1} R] [_inst_6 : Preorder.{u1} R] [_inst_7 : Sub.{u1} R] [_inst_8 : OrderedSub.{u1} R (Preorder.toHasLe.{u1} R _inst_6) (Distrib.toHasAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) _inst_7] [_inst_9 : CovariantClass.{u1, u1} R R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_6))] {a : R} {b : R} {c : R}, LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_6) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5)))))) a c) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5)))))) b c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5)))))) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) a b) c)
 but is expected to have type
   forall {R : Type.{u1}} [_inst_5 : CommSemiring.{u1} R] [_inst_6 : Preorder.{u1} R] [_inst_7 : Sub.{u1} R] [_inst_8 : OrderedSub.{u1} R (Preorder.toLE.{u1} R _inst_6) (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) _inst_7] [_inst_9 : CovariantClass.{u1, u1} R R (fun (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.270 : R) (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.272 : R) => HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.270 x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.272) (fun (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.285 : R) (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.287 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.285 x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.287)] {a : R} {b : R} {c : R}, LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) a c) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) b c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) a b) c)
 Case conversion may be inaccurate. Consider using '#align le_tsub_mul le_tsub_mulₓ'. -/
@@ -63,7 +67,7 @@ end Add
 
 /- warning: order_iso.map_tsub -> OrderIso.map_tsub is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Preorder.{u1} M] [_inst_2 : Add.{u1} M] [_inst_3 : Sub.{u1} M] [_inst_4 : OrderedSub.{u1} M (Preorder.toLE.{u1} M _inst_1) _inst_2 _inst_3] [_inst_5 : PartialOrder.{u2} N] [_inst_6 : Add.{u2} N] [_inst_7 : Sub.{u2} N] [_inst_8 : OrderedSub.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)) _inst_6 _inst_7] (e : OrderIso.{u1, u2} M N (Preorder.toLE.{u1} M _inst_1) (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))), (forall (a : M) (b : M), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toLE.{u1} M _inst_1) (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M _inst_2) a b)) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N _inst_6) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toLE.{u1} M _inst_1) (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e a) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toLE.{u1} M _inst_1) (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e b))) -> (forall (a : M) (b : M), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toLE.{u1} M _inst_1) (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e (HSub.hSub.{u1, u1, u1} M M M (instHSub.{u1} M _inst_3) a b)) (HSub.hSub.{u2, u2, u2} N N N (instHSub.{u2} N _inst_7) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toLE.{u1} M _inst_1) (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e a) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toLE.{u1} M _inst_1) (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e b)))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Preorder.{u1} M] [_inst_2 : Add.{u1} M] [_inst_3 : Sub.{u1} M] [_inst_4 : OrderedSub.{u1} M (Preorder.toHasLe.{u1} M _inst_1) _inst_2 _inst_3] [_inst_5 : PartialOrder.{u2} N] [_inst_6 : Add.{u2} N] [_inst_7 : Sub.{u2} N] [_inst_8 : OrderedSub.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)) _inst_6 _inst_7] (e : OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))), (forall (a : M) (b : M), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M _inst_2) a b)) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N _inst_6) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e a) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e b))) -> (forall (a : M) (b : M), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e (HSub.hSub.{u1, u1, u1} M M M (instHSub.{u1} M _inst_3) a b)) (HSub.hSub.{u2, u2, u2} N N N (instHSub.{u2} N _inst_7) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e a) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toHasLe.{u1} M _inst_1) (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e b)))
 but is expected to have type
   forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Preorder.{u2} M] [_inst_2 : Add.{u2} M] [_inst_3 : Sub.{u2} M] [_inst_4 : OrderedSub.{u2} M (Preorder.toLE.{u2} M _inst_1) _inst_2 _inst_3] [_inst_5 : PartialOrder.{u1} N] [_inst_6 : Add.{u1} N] [_inst_7 : Sub.{u1} N] [_inst_8 : OrderedSub.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) _inst_6 _inst_7] (e : OrderIso.{u2, u1} M N (Preorder.toLE.{u2} M _inst_1) (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5))), (forall (a : M) (b : M), Eq.{succ u1} N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e (HAdd.hAdd.{u2, u2, u2} M M M (instHAdd.{u2} M _inst_2) a b)) (HAdd.hAdd.{u1, u1, u1} N N N (instHAdd.{u1} N _inst_6) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e b))) -> (forall (a : M) (b : M), Eq.{succ u1} N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e (HSub.hSub.{u2, u2, u2} M M M (instHSub.{u2} M _inst_3) a b)) (HSub.hSub.{u1, u1, u1} N N N (instHSub.{u1} N _inst_7) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e b)))
 Case conversion may be inaccurate. Consider using '#align order_iso.map_tsub OrderIso.map_tsubₓ'. -/
@@ -90,7 +94,7 @@ variable [AddCommMonoid α] [Sub α] [OrderedSub α] {a b c d : α}
 
 /- warning: add_monoid_hom.le_map_tsub -> AddMonoidHom.le_map_tsub is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] [_inst_5 : Preorder.{u2} β] [_inst_6 : AddCommMonoid.{u2} β] [_inst_7 : Sub.{u2} β] [_inst_8 : OrderedSub.{u2} β (Preorder.toLE.{u2} β _inst_5) (AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) _inst_7] (f : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))), (Monotone.{u1, u2} α β _inst_1 _inst_5 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (fun (_x : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) => α -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) f)) -> (forall (a : α) (b : α), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_5) (HSub.hSub.{u2, u2, u2} β β β (instHSub.{u2} β _inst_7) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (fun (_x : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) => α -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) f a) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (fun (_x : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) => α -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) f b)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (fun (_x : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) => α -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] [_inst_5 : Preorder.{u2} β] [_inst_6 : AddCommMonoid.{u2} β] [_inst_7 : Sub.{u2} β] [_inst_8 : OrderedSub.{u2} β (Preorder.toHasLe.{u2} β _inst_5) (AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) _inst_7] (f : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))), (Monotone.{u1, u2} α β _inst_1 _inst_5 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (fun (_x : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) => α -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) f)) -> (forall (a : α) (b : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_5) (HSub.hSub.{u2, u2, u2} β β β (instHSub.{u2} β _inst_7) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (fun (_x : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) => α -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) f a) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (fun (_x : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) => α -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) f b)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (fun (_x : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) => α -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] [_inst_5 : Preorder.{u2} β] [_inst_6 : AddCommMonoid.{u2} β] [_inst_7 : Sub.{u2} β] [_inst_8 : OrderedSub.{u2} β (Preorder.toLE.{u2} β _inst_5) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) _inst_7] (f : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))), (Monotone.{u1, u2} α β _inst_1 _inst_5 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6)) (AddMonoidHom.addMonoidHomClass.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))))) f)) -> (forall (a : α) (b : α), LE.le.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) (Preorder.toLE.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) _inst_5) (HSub.hSub.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) b) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) (instHSub.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) _inst_7) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6)) (AddMonoidHom.addMonoidHomClass.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))))) f a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6)) (AddMonoidHom.addMonoidHomClass.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))))) f b)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6)) (AddMonoidHom.addMonoidHomClass.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))))) f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)))
 Case conversion may be inaccurate. Consider using '#align add_monoid_hom.le_map_tsub AddMonoidHom.le_map_tsubₓ'. -/

448144f7

bump to nightly-2023-04-20-10

mathlib commit https://github.com/leanprover-community/mathlib/commit/730c6d4cab72b9d84fcfb9e95e8796e9cd8f40ba

fbfe5c3e

Diff

@@ -65,7 +65,7 @@ end Add
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Preorder.{u1} M] [_inst_2 : Add.{u1} M] [_inst_3 : Sub.{u1} M] [_inst_4 : OrderedSub.{u1} M (Preorder.toLE.{u1} M _inst_1) _inst_2 _inst_3] [_inst_5 : PartialOrder.{u2} N] [_inst_6 : Add.{u2} N] [_inst_7 : Sub.{u2} N] [_inst_8 : OrderedSub.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)) _inst_6 _inst_7] (e : OrderIso.{u1, u2} M N (Preorder.toLE.{u1} M _inst_1) (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))), (forall (a : M) (b : M), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toLE.{u1} M _inst_1) (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M _inst_2) a b)) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N _inst_6) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toLE.{u1} M _inst_1) (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e a) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toLE.{u1} M _inst_1) (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e b))) -> (forall (a : M) (b : M), Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toLE.{u1} M _inst_1) (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e (HSub.hSub.{u1, u1, u1} M M M (instHSub.{u1} M _inst_3) a b)) (HSub.hSub.{u2, u2, u2} N N N (instHSub.{u2} N _inst_7) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toLE.{u1} M _inst_1) (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e a) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} M N (Preorder.toLE.{u1} M _inst_1) (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5))) (fun (_x : RelIso.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) => M -> N) (RelIso.hasCoeToFun.{u1, u2} M N (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_1)) (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N _inst_5)))) e b)))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Preorder.{u2} M] [_inst_2 : Add.{u2} M] [_inst_3 : Sub.{u2} M] [_inst_4 : OrderedSub.{u2} M (Preorder.toLE.{u2} M _inst_1) _inst_2 _inst_3] [_inst_5 : PartialOrder.{u1} N] [_inst_6 : Add.{u1} N] [_inst_7 : Sub.{u1} N] [_inst_8 : OrderedSub.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) _inst_6 _inst_7] (e : OrderIso.{u2, u1} M N (Preorder.toLE.{u2} M _inst_1) (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5))), (forall (a : M) (b : M), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) (HAdd.hAdd.{u2, u2, u2} M M M (instHAdd.{u2} M _inst_2) a b)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} M N) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} M N) M N (Function.instEmbeddingLikeEmbedding.{succ u2, succ u1} M N)) (RelEmbedding.toEmbedding.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) e)) (HAdd.hAdd.{u2, u2, u2} M M M (instHAdd.{u2} M _inst_2) a b)) (HAdd.hAdd.{u1, u1, u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) b) ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) (instHAdd.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) _inst_6) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} M N) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} M N) M N (Function.instEmbeddingLikeEmbedding.{succ u2, succ u1} M N)) (RelEmbedding.toEmbedding.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) e)) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} M N) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} M N) M N (Function.instEmbeddingLikeEmbedding.{succ u2, succ u1} M N)) (RelEmbedding.toEmbedding.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) e)) b))) -> (forall (a : M) (b : M), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) (HSub.hSub.{u2, u2, u2} M M M (instHSub.{u2} M _inst_3) a b)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} M N) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} M N) M N (Function.instEmbeddingLikeEmbedding.{succ u2, succ u1} M N)) (RelEmbedding.toEmbedding.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) e)) (HSub.hSub.{u2, u2, u2} M M M (instHSub.{u2} M _inst_3) a b)) (HSub.hSub.{u1, u1, u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) b) ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) (instHSub.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) a) _inst_7) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} M N) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} M N) M N (Function.instEmbeddingLikeEmbedding.{succ u2, succ u1} M N)) (RelEmbedding.toEmbedding.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) e)) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} M N) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} M N) M N (Function.instEmbeddingLikeEmbedding.{succ u2, succ u1} M N)) (RelEmbedding.toEmbedding.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) e)) b)))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Preorder.{u2} M] [_inst_2 : Add.{u2} M] [_inst_3 : Sub.{u2} M] [_inst_4 : OrderedSub.{u2} M (Preorder.toLE.{u2} M _inst_1) _inst_2 _inst_3] [_inst_5 : PartialOrder.{u1} N] [_inst_6 : Add.{u1} N] [_inst_7 : Sub.{u1} N] [_inst_8 : OrderedSub.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) _inst_6 _inst_7] (e : OrderIso.{u2, u1} M N (Preorder.toLE.{u2} M _inst_1) (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5))), (forall (a : M) (b : M), Eq.{succ u1} N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e (HAdd.hAdd.{u2, u2, u2} M M M (instHAdd.{u2} M _inst_2) a b)) (HAdd.hAdd.{u1, u1, u1} N N N (instHAdd.{u1} N _inst_6) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e b))) -> (forall (a : M) (b : M), Eq.{succ u1} N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e (HSub.hSub.{u2, u2, u2} M M M (instHSub.{u2} M _inst_3) a b)) (HSub.hSub.{u1, u1, u1} N N N (instHSub.{u1} N _inst_7) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M (fun (_x : M) => N) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} M N (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : M) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : N) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : N) => LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N _inst_5)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) e b)))
 Case conversion may be inaccurate. Consider using '#align order_iso.map_tsub OrderIso.map_tsubₓ'. -/
 /-- An order isomorphism between types with ordered subtraction preserves subtraction provided that
 it preserves addition. -/

448144f7

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -41,7 +41,7 @@ theorem AddHom.le_map_tsub [Preorder β] [Add β] [Sub β] [OrderedSub β] (f :
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_5 : Distrib.{u1} R] [_inst_6 : Preorder.{u1} R] [_inst_7 : Sub.{u1} R] [_inst_8 : OrderedSub.{u1} R (Preorder.toLE.{u1} R _inst_6) (Distrib.toHasAdd.{u1} R _inst_5) _inst_7] [_inst_9 : CovariantClass.{u1, u1} R R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R _inst_5))) (LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6))] {a : R} {b : R} {c : R}, LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R _inst_5)) a b) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R _inst_5)) a c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R _inst_5)) a (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) b c))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_5 : Distrib.{u1} R] [_inst_6 : Preorder.{u1} R] [_inst_7 : Sub.{u1} R] [_inst_8 : OrderedSub.{u1} R (Preorder.toLE.{u1} R _inst_6) (Distrib.toAdd.{u1} R _inst_5) _inst_7] [_inst_9 : CovariantClass.{u1, u1} R R (fun (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.170 : R) (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.172 : R) => HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toMul.{u1} R _inst_5)) x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.170 x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.172) (fun (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.185 : R) (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.187 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.185 x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.187)] {a : R} {b : R} {c : R}, LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toMul.{u1} R _inst_5)) a b) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toMul.{u1} R _inst_5)) a c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toMul.{u1} R _inst_5)) a (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) b c))
+  forall {R : Type.{u1}} [_inst_5 : Distrib.{u1} R] [_inst_6 : Preorder.{u1} R] [_inst_7 : Sub.{u1} R] [_inst_8 : OrderedSub.{u1} R (Preorder.toLE.{u1} R _inst_6) (Distrib.toAdd.{u1} R _inst_5) _inst_7] [_inst_9 : CovariantClass.{u1, u1} R R (fun (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.174 : R) (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.176 : R) => HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toMul.{u1} R _inst_5)) x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.174 x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.176) (fun (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.189 : R) (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.191 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.189 x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.191)] {a : R} {b : R} {c : R}, LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toMul.{u1} R _inst_5)) a b) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toMul.{u1} R _inst_5)) a c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toMul.{u1} R _inst_5)) a (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) b c))
 Case conversion may be inaccurate. Consider using '#align le_mul_tsub le_mul_tsubₓ'. -/
 theorem le_mul_tsub {R : Type _} [Distrib R] [Preorder R] [Sub R] [OrderedSub R]
     [CovariantClass R R (· * ·) (· ≤ ·)] {a b c : R} : a * b - a * c ≤ a * (b - c) :=
@@ -52,7 +52,7 @@ theorem le_mul_tsub {R : Type _} [Distrib R] [Preorder R] [Sub R] [OrderedSub R]
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_5 : CommSemiring.{u1} R] [_inst_6 : Preorder.{u1} R] [_inst_7 : Sub.{u1} R] [_inst_8 : OrderedSub.{u1} R (Preorder.toLE.{u1} R _inst_6) (Distrib.toHasAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) _inst_7] [_inst_9 : CovariantClass.{u1, u1} R R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))))) (LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6))] {a : R} {b : R} {c : R}, LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5)))))) a c) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5)))))) b c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5)))))) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) a b) c)
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_5 : CommSemiring.{u1} R] [_inst_6 : Preorder.{u1} R] [_inst_7 : Sub.{u1} R] [_inst_8 : OrderedSub.{u1} R (Preorder.toLE.{u1} R _inst_6) (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) _inst_7] [_inst_9 : CovariantClass.{u1, u1} R R (fun (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.266 : R) (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.268 : R) => HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.266 x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.268) (fun (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.281 : R) (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.283 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.281 x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.283)] {a : R} {b : R} {c : R}, LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) a c) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) b c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) a b) c)
+  forall {R : Type.{u1}} [_inst_5 : CommSemiring.{u1} R] [_inst_6 : Preorder.{u1} R] [_inst_7 : Sub.{u1} R] [_inst_8 : OrderedSub.{u1} R (Preorder.toLE.{u1} R _inst_6) (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) _inst_7] [_inst_9 : CovariantClass.{u1, u1} R R (fun (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.270 : R) (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.272 : R) => HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.270 x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.272) (fun (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.285 : R) (x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.287 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.285 x._@.Mathlib.Algebra.Order.Sub.Basic._hyg.287)] {a : R} {b : R} {c : R}, LE.le.{u1} R (Preorder.toLE.{u1} R _inst_6) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) a c) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) b c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R _inst_5))))) (HSub.hSub.{u1, u1, u1} R R R (instHSub.{u1} R _inst_7) a b) c)
 Case conversion may be inaccurate. Consider using '#align le_tsub_mul le_tsub_mulₓ'. -/
 theorem le_tsub_mul {R : Type _} [CommSemiring R] [Preorder R] [Sub R] [OrderedSub R]
     [CovariantClass R R (· * ·) (· ≤ ·)] {a b c : R} : a * c - b * c ≤ (a - b) * c := by
@@ -92,7 +92,7 @@ variable [AddCommMonoid α] [Sub α] [OrderedSub α] {a b c d : α}
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] [_inst_5 : Preorder.{u2} β] [_inst_6 : AddCommMonoid.{u2} β] [_inst_7 : Sub.{u2} β] [_inst_8 : OrderedSub.{u2} β (Preorder.toLE.{u2} β _inst_5) (AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) _inst_7] (f : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))), (Monotone.{u1, u2} α β _inst_1 _inst_5 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (fun (_x : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) => α -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) f)) -> (forall (a : α) (b : α), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_5) (HSub.hSub.{u2, u2, u2} β β β (instHSub.{u2} β _inst_7) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (fun (_x : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) => α -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) f a) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (fun (_x : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) => α -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) f b)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (fun (_x : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) => α -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] [_inst_5 : Preorder.{u2} β] [_inst_6 : AddCommMonoid.{u2} β] [_inst_7 : Sub.{u2} β] [_inst_8 : OrderedSub.{u2} β (Preorder.toLE.{u2} β _inst_5) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) _inst_7] (f : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))), (Monotone.{u1, u2} α β _inst_1 _inst_5 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6)) (AddMonoidHom.addMonoidHomClass.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))))) f)) -> (forall (a : α) (b : α), LE.le.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : α) => β) a) (Preorder.toLE.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : α) => β) a) _inst_5) (HSub.hSub.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : α) => β) b) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : α) => β) a) (instHSub.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : α) => β) a) _inst_7) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6)) (AddMonoidHom.addMonoidHomClass.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))))) f a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6)) (AddMonoidHom.addMonoidHomClass.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))))) f b)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6)) (AddMonoidHom.addMonoidHomClass.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))))) f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] [_inst_5 : Preorder.{u2} β] [_inst_6 : AddCommMonoid.{u2} β] [_inst_7 : Sub.{u2} β] [_inst_8 : OrderedSub.{u2} β (Preorder.toLE.{u2} β _inst_5) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) _inst_7] (f : AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))), (Monotone.{u1, u2} α β _inst_1 _inst_5 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6)) (AddMonoidHom.addMonoidHomClass.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))))) f)) -> (forall (a : α) (b : α), LE.le.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) (Preorder.toLE.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) _inst_5) (HSub.hSub.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) b) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) (instHSub.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) a) _inst_7) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6)) (AddMonoidHom.addMonoidHomClass.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))))) f a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6)) (AddMonoidHom.addMonoidHomClass.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))))) f b)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))) α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6)) (AddMonoidHom.addMonoidHomClass.{u1, u2} α β (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)) (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_6))))) f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)))
 Case conversion may be inaccurate. Consider using '#align add_monoid_hom.le_map_tsub AddMonoidHom.le_map_tsubₓ'. -/
 theorem AddMonoidHom.le_map_tsub [Preorder β] [AddCommMonoid β] [Sub β] [OrderedSub β] (f : α →+ β)
     (hf : Monotone f) (a b : α) : f a - f b ≤ f (a - b) :=

448144f7

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

10b4e499

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

Empty lines were removed by executing the following Python script twice

import os
import re


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

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

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

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

75c86f04

Diff

@@ -57,7 +57,6 @@ theorem OrderIso.map_tsub {M N : Type*} [Preorder M] [Add M] [Sub M] [OrderedSub
 section Preorder
 
 variable [Preorder α]
-
 variable [AddCommMonoid α] [Sub α] [OrderedSub α] {a b c d : α}
 
 theorem AddMonoidHom.le_map_tsub [Preorder β] [AddCommMonoid β] [Sub β] [OrderedSub β] (f : α →+ β)

10b4e499

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

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

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

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

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

92fe122e

Diff

@@ -3,10 +3,10 @@ Copyright (c) 2021 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
 -/
-import Mathlib.Order.Hom.Basic
-import Mathlib.Algebra.Hom.Equiv.Basic
+import Mathlib.Algebra.Group.Equiv.Basic
 import Mathlib.Algebra.Ring.Basic
 import Mathlib.Algebra.Order.Sub.Defs
+import Mathlib.Order.Hom.Basic
 
 #align_import algebra.order.sub.basic from "leanprover-community/mathlib"@"10b4e499f43088dd3bb7b5796184ad5216648ab1"

10b4e499

chore: banish Type _ and Sort _ (#6499)

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

This has nice performance benefits.

32de3f67

Diff

@@ -16,7 +16,7 @@ import Mathlib.Algebra.Order.Sub.Defs
 -/
 
 
-variable {α β : Type _}
+variable {α β : Type*}
 
 section Add
 
@@ -28,12 +28,12 @@ theorem AddHom.le_map_tsub [Preorder β] [Add β] [Sub β] [OrderedSub β] (f :
   exact hf le_tsub_add
 #align add_hom.le_map_tsub AddHom.le_map_tsub
 
-theorem le_mul_tsub {R : Type _} [Distrib R] [Preorder R] [Sub R] [OrderedSub R]
+theorem le_mul_tsub {R : Type*} [Distrib R] [Preorder R] [Sub R] [OrderedSub R]
     [CovariantClass R R (· * ·) (· ≤ ·)] {a b c : R} : a * b - a * c ≤ a * (b - c) :=
   (AddHom.mulLeft a).le_map_tsub (monotone_id.const_mul' a) _ _
 #align le_mul_tsub le_mul_tsub
 
-theorem le_tsub_mul {R : Type _} [CommSemiring R] [Preorder R] [Sub R] [OrderedSub R]
+theorem le_tsub_mul {R : Type*} [CommSemiring R] [Preorder R] [Sub R] [OrderedSub R]
     [CovariantClass R R (· * ·) (· ≤ ·)] {a b c : R} : a * c - b * c ≤ (a - b) * c := by
   simpa only [mul_comm _ c] using le_mul_tsub
 #align le_tsub_mul le_tsub_mul
@@ -42,7 +42,7 @@ end Add
 
 /-- An order isomorphism between types with ordered subtraction preserves subtraction provided that
 it preserves addition. -/
-theorem OrderIso.map_tsub {M N : Type _} [Preorder M] [Add M] [Sub M] [OrderedSub M]
+theorem OrderIso.map_tsub {M N : Type*} [Preorder M] [Add M] [Sub M] [OrderedSub M]
     [PartialOrder N] [Add N] [Sub N] [OrderedSub N] (e : M ≃o N)
     (h_add : ∀ a b, e (a + b) = e a + e b) (a b : M) : e (a - b) = e a - e b := by
   let e_add : M ≃+ N := { e with map_add' := h_add }

10b4e499

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

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

89aa3a3b

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2021 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
-
-! This file was ported from Lean 3 source module algebra.order.sub.basic
-! leanprover-community/mathlib commit 10b4e499f43088dd3bb7b5796184ad5216648ab1
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.Hom.Basic
 import Mathlib.Algebra.Hom.Equiv.Basic
 import Mathlib.Algebra.Ring.Basic
 import Mathlib.Algebra.Order.Sub.Defs
 
+#align_import algebra.order.sub.basic from "leanprover-community/mathlib"@"10b4e499f43088dd3bb7b5796184ad5216648ab1"
+
 /-!
 # Additional results about ordered Subtraction

10b4e499

chore: add source headers to ported theory files (#1094)

The script used to do this is included. The yaml file was obtained from https://raw.githubusercontent.com/wiki/leanprover-community/mathlib/mathlib4-port-status.md

f168625e

Diff

@@ -2,6 +2,11 @@
 Copyright (c) 2021 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
+
+! This file was ported from Lean 3 source module algebra.order.sub.basic
+! leanprover-community/mathlib commit 10b4e499f43088dd3bb7b5796184ad5216648ab1
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Order.Hom.Basic
 import Mathlib.Algebra.Hom.Equiv.Basic

`algebra.order.sub.basic` ⟷ `Mathlib.Algebra.Order.Sub.Basic`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 50

algebra.order.sub.basic ⟷ Mathlib.Algebra.Order.Sub.Basic

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 50

`algebra.order.sub.basic` ⟷ `Mathlib.Algebra.Order.Sub.Basic`