data.finsupp.lex ⟷ Mathlib.Data.Finsupp.Lex

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

@@ -4,8 +4,8 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Damiano Testa
 -/
 import Data.Finsupp.Order
-import Data.Dfinsupp.Lex
-import Data.Finsupp.ToDfinsupp
+import Data.DFinsupp.Lex
+import Data.Finsupp.ToDFinsupp
 
 #align_import data.finsupp.lex from "leanprover-community/mathlib"@"1ead22342e1a078bd44744ace999f85756555d35"
 

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

@@ -3,9 +3,9 @@ Copyright (c) 2022 Damiano Testa. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Damiano Testa
 -/
-import Mathbin.Data.Finsupp.Order
-import Mathbin.Data.Dfinsupp.Lex
-import Mathbin.Data.Finsupp.ToDfinsupp
+import Data.Finsupp.Order
+import Data.Dfinsupp.Lex
+import Data.Finsupp.ToDfinsupp
 
 #align_import data.finsupp.lex from "leanprover-community/mathlib"@"1ead22342e1a078bd44744ace999f85756555d35"
 

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

@@ -2,16 +2,13 @@
 Copyright (c) 2022 Damiano Testa. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Damiano Testa
-
-! This file was ported from Lean 3 source module data.finsupp.lex
-! leanprover-community/mathlib commit 1ead22342e1a078bd44744ace999f85756555d35
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Finsupp.Order
 import Mathbin.Data.Dfinsupp.Lex
 import Mathbin.Data.Finsupp.ToDfinsupp
 
+#align_import data.finsupp.lex from "leanprover-community/mathlib"@"1ead22342e1a078bd44744ace999f85756555d35"
+
 /-!
 # Lexicographic order on finitely supported functions
 

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

@@ -57,7 +57,7 @@ theorem lex_def {r : α → α → Prop} {s : N → N → Prop} {a b : α →₀
 
 #print Finsupp.lex_eq_invImage_dfinsupp_lex /-
 theorem lex_eq_invImage_dfinsupp_lex (r : α → α → Prop) (s : N → N → Prop) :
-    Finsupp.Lex r s = InvImage (Dfinsupp.Lex r fun a => s) toDfinsupp :=
+    Finsupp.Lex r s = InvImage (DFinsupp.Lex r fun a => s) toDFinsupp :=
   rfl
 #align finsupp.lex_eq_inv_image_dfinsupp_lex Finsupp.lex_eq_invImage_dfinsupp_lex
 -/
@@ -68,14 +68,14 @@ instance [LT α] [LT N] : LT (Lex (α →₀ N)) :=
 #print Finsupp.lex_lt_of_lt_of_preorder /-
 theorem lex_lt_of_lt_of_preorder [Preorder N] (r) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y) :
     ∃ i, (∀ j, r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i :=
-  Dfinsupp.lex_lt_of_lt_of_preorder r (id hlt : x.toDfinsupp < y.toDfinsupp)
+  DFinsupp.lex_lt_of_lt_of_preorder r (id hlt : x.toDFinsupp < y.toDFinsupp)
 #align finsupp.lex_lt_of_lt_of_preorder Finsupp.lex_lt_of_lt_of_preorder
 -/
 
 #print Finsupp.lex_lt_of_lt /-
 theorem lex_lt_of_lt [PartialOrder N] (r) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y) :
     Pi.Lex r (fun i => (· < ·)) x y :=
-  Dfinsupp.lex_lt_of_lt r (id hlt : x.toDfinsupp < y.toDfinsupp)
+  DFinsupp.lex_lt_of_lt r (id hlt : x.toDFinsupp < y.toDFinsupp)
 #align finsupp.lex_lt_of_lt Finsupp.lex_lt_of_lt
 -/
 
@@ -103,7 +103,7 @@ instance Lex.partialOrder [PartialOrder N] : PartialOrder (Lex (α →₀ N)) :=
 /-- The linear order on `finsupp`s obtained by the lexicographic ordering. -/
 instance Lex.linearOrder [LinearOrder N] : LinearOrder (Lex (α →₀ N)) :=
   { Lex.partialOrder,
-    LinearOrder.lift' (toLex ∘ toDfinsupp ∘ ofLex) finsuppEquivDfinsupp.Injective with }
+    LinearOrder.lift' (toLex ∘ toDFinsupp ∘ ofLex) finsuppEquivDFinsupp.Injective with }
 #align finsupp.lex.linear_order Finsupp.Lex.linearOrder
 -/
 
@@ -111,7 +111,7 @@ variable [PartialOrder N]
 
 #print Finsupp.toLex_monotone /-
 theorem toLex_monotone : Monotone (@toLex (α →₀ N)) := fun a b h =>
-  Dfinsupp.toLex_monotone (id h : ∀ i, ofLex (toDfinsupp a) i ≤ ofLex (toDfinsupp b) i)
+  DFinsupp.toLex_monotone (id h : ∀ i, ofLex (toDFinsupp a) i ≤ ofLex (toDFinsupp b) i)
 #align finsupp.to_lex_monotone Finsupp.toLex_monotone
 -/
 

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

@@ -41,20 +41,26 @@ protected def Lex (r : α → α → Prop) (s : N → N → Prop) (x y : α →
 #align finsupp.lex Finsupp.Lex
 -/
 
+#print Pi.lex_eq_finsupp_lex /-
 theorem Pi.lex_eq_finsupp_lex {r : α → α → Prop} {s : N → N → Prop} (a b : α →₀ N) :
     Pi.Lex r (fun _ => s) (a : α → N) (b : α → N) = Finsupp.Lex r s a b :=
   rfl
 #align pi.lex_eq_finsupp_lex Pi.lex_eq_finsupp_lex
+-/
 
+#print Finsupp.lex_def /-
 theorem lex_def {r : α → α → Prop} {s : N → N → Prop} {a b : α →₀ N} :
     Finsupp.Lex r s a b ↔ ∃ j, (∀ d, r d j → a d = b d) ∧ s (a j) (b j) :=
   Iff.rfl
 #align finsupp.lex_def Finsupp.lex_def
+-/
 
+#print Finsupp.lex_eq_invImage_dfinsupp_lex /-
 theorem lex_eq_invImage_dfinsupp_lex (r : α → α → Prop) (s : N → N → Prop) :
     Finsupp.Lex r s = InvImage (Dfinsupp.Lex r fun a => s) toDfinsupp :=
   rfl
 #align finsupp.lex_eq_inv_image_dfinsupp_lex Finsupp.lex_eq_invImage_dfinsupp_lex
+-/
 
 instance [LT α] [LT N] : LT (Lex (α →₀ N)) :=
   ⟨fun f g => Finsupp.Lex (· < ·) (· < ·) (ofLex f) (ofLex g)⟩
@@ -73,12 +79,14 @@ theorem lex_lt_of_lt [PartialOrder N] (r) [IsStrictOrder α r] {x y : α →₀
 #align finsupp.lex_lt_of_lt Finsupp.lex_lt_of_lt
 -/
 
+#print Finsupp.Lex.isStrictOrder /-
 instance Lex.isStrictOrder [LinearOrder α] [PartialOrder N] :
     IsStrictOrder (Lex (α →₀ N)) (· < ·) :=
   let i : IsStrictOrder (Lex (α → N)) (· < ·) := Pi.Lex.isStrictOrder
   { irrefl := toLex.Surjective.forall.2 fun a => @irrefl _ _ i.to_isIrrefl a
     trans := toLex.Surjective.forall₃.2 fun a b c => @trans _ _ i.to_isTrans a b c }
 #align finsupp.lex.is_strict_order Finsupp.Lex.isStrictOrder
+-/
 
 variable [LinearOrder α]
 
@@ -101,9 +109,11 @@ instance Lex.linearOrder [LinearOrder N] : LinearOrder (Lex (α →₀ N)) :=
 
 variable [PartialOrder N]
 
+#print Finsupp.toLex_monotone /-
 theorem toLex_monotone : Monotone (@toLex (α →₀ N)) := fun a b h =>
   Dfinsupp.toLex_monotone (id h : ∀ i, ofLex (toDfinsupp a) i ≤ ofLex (toDfinsupp b) i)
 #align finsupp.to_lex_monotone Finsupp.toLex_monotone
+-/
 
 #print Finsupp.lt_of_forall_lt_of_lt /-
 theorem lt_of_forall_lt_of_lt (a b : Lex (α →₀ N)) (i : α) :
@@ -129,16 +139,20 @@ section Left
 
 variable [CovariantClass N N (· + ·) (· < ·)]
 
+#print Finsupp.Lex.covariantClass_lt_left /-
 instance Lex.covariantClass_lt_left :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (· + ·) (· < ·) :=
   ⟨fun f g h ⟨a, lta, ha⟩ =>
     ⟨a, fun j ja => congr_arg ((· + ·) _) (lta j ja), add_lt_add_left ha _⟩⟩
 #align finsupp.lex.covariant_class_lt_left Finsupp.Lex.covariantClass_lt_left
+-/
 
+#print Finsupp.Lex.covariantClass_le_left /-
 instance Lex.covariantClass_le_left :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (· + ·) (· ≤ ·) :=
   Add.to_covariantClass_left _
 #align finsupp.lex.covariant_class_le_left Finsupp.Lex.covariantClass_le_left
+-/
 
 end Left
 
@@ -146,16 +160,20 @@ section Right
 
 variable [CovariantClass N N (Function.swap (· + ·)) (· < ·)]
 
+#print Finsupp.Lex.covariantClass_lt_right /-
 instance Lex.covariantClass_lt_right :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (Function.swap (· + ·)) (· < ·) :=
   ⟨fun f g h ⟨a, lta, ha⟩ =>
     ⟨a, fun j ja => congr_arg (· + ofLex f j) (lta j ja), add_lt_add_right ha _⟩⟩
 #align finsupp.lex.covariant_class_lt_right Finsupp.Lex.covariantClass_lt_right
+-/
 
+#print Finsupp.Lex.covariantClass_le_right /-
 instance Lex.covariantClass_le_right :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (Function.swap (· + ·)) (· ≤ ·) :=
   Add.to_covariantClass_right _
 #align finsupp.lex.covariant_class_le_right Finsupp.Lex.covariantClass_le_right
+-/
 
 end Right
 

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

@@ -59,15 +59,19 @@ theorem lex_eq_invImage_dfinsupp_lex (r : α → α → Prop) (s : N → N → P
 instance [LT α] [LT N] : LT (Lex (α →₀ N)) :=
   ⟨fun f g => Finsupp.Lex (· < ·) (· < ·) (ofLex f) (ofLex g)⟩
 
+#print Finsupp.lex_lt_of_lt_of_preorder /-
 theorem lex_lt_of_lt_of_preorder [Preorder N] (r) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y) :
     ∃ i, (∀ j, r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i :=
   Dfinsupp.lex_lt_of_lt_of_preorder r (id hlt : x.toDfinsupp < y.toDfinsupp)
 #align finsupp.lex_lt_of_lt_of_preorder Finsupp.lex_lt_of_lt_of_preorder
+-/
 
+#print Finsupp.lex_lt_of_lt /-
 theorem lex_lt_of_lt [PartialOrder N] (r) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y) :
     Pi.Lex r (fun i => (· < ·)) x y :=
   Dfinsupp.lex_lt_of_lt r (id hlt : x.toDfinsupp < y.toDfinsupp)
 #align finsupp.lex_lt_of_lt Finsupp.lex_lt_of_lt
+-/
 
 instance Lex.isStrictOrder [LinearOrder α] [PartialOrder N] :
     IsStrictOrder (Lex (α →₀ N)) (· < ·) :=
@@ -101,9 +105,11 @@ theorem toLex_monotone : Monotone (@toLex (α →₀ N)) := fun a b h =>
   Dfinsupp.toLex_monotone (id h : ∀ i, ofLex (toDfinsupp a) i ≤ ofLex (toDfinsupp b) i)
 #align finsupp.to_lex_monotone Finsupp.toLex_monotone
 
+#print Finsupp.lt_of_forall_lt_of_lt /-
 theorem lt_of_forall_lt_of_lt (a b : Lex (α →₀ N)) (i : α) :
     (∀ j < i, ofLex a j = ofLex b j) → ofLex a i < ofLex b i → a < b := fun h1 h2 => ⟨i, h1, h2⟩
 #align finsupp.lt_of_forall_lt_of_lt Finsupp.lt_of_forall_lt_of_lt
+-/
 
 end NHasZero
 

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

@@ -41,34 +41,16 @@ protected def Lex (r : α → α → Prop) (s : N → N → Prop) (x y : α →
 #align finsupp.lex Finsupp.Lex
 -/
 
-/- warning: pi.lex_eq_finsupp_lex -> Pi.lex_eq_finsupp_lex is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] {r : α -> α -> Prop} {s : N -> N -> Prop} (a : Finsupp.{u1, u2} α N _inst_1) (b : Finsupp.{u1, u2} α N _inst_1), Eq.{1} Prop (Pi.Lex.{u1, u2} α (fun (_x : α) => N) r (fun (_x : α) => s) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) a) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) b)) (Finsupp.Lex.{u1, u2} α N _inst_1 r s a b)
-but is expected to have type
-  forall {α : Type.{u2}} {N : Type.{u1}} [_inst_1 : Zero.{u1} N] {r : α -> α -> Prop} {s : N -> N -> Prop} (a : Finsupp.{u2, u1} α N _inst_1) (b : Finsupp.{u2, u1} α N _inst_1), Eq.{1} Prop (Pi.Lex.{u2, u1} α (fun {_x : α} => N) r (fun {_x : α} => s) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Finsupp.{u2, u1} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u2, u1} α N _inst_1) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Finsupp.{u2, u1} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u2, u1} α N _inst_1) b)) (Finsupp.Lex.{u2, u1} α N _inst_1 r s a b)
-Case conversion may be inaccurate. Consider using '#align pi.lex_eq_finsupp_lex Pi.lex_eq_finsupp_lexₓ'. -/
 theorem Pi.lex_eq_finsupp_lex {r : α → α → Prop} {s : N → N → Prop} (a b : α →₀ N) :
     Pi.Lex r (fun _ => s) (a : α → N) (b : α → N) = Finsupp.Lex r s a b :=
   rfl
 #align pi.lex_eq_finsupp_lex Pi.lex_eq_finsupp_lex
 
-/- warning: finsupp.lex_def -> Finsupp.lex_def is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] {r : α -> α -> Prop} {s : N -> N -> Prop} {a : Finsupp.{u1, u2} α N _inst_1} {b : Finsupp.{u1, u2} α N _inst_1}, Iff (Finsupp.Lex.{u1, u2} α N _inst_1 r s a b) (Exists.{succ u1} α (fun (j : α) => And (forall (d : α), (r d j) -> (Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) a d) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) b d))) (s (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) a j) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) b j))))
-but is expected to have type
-  forall {α : Type.{u2}} {N : Type.{u1}} [_inst_1 : Zero.{u1} N] {r : α -> α -> Prop} {s : N -> N -> Prop} {a : Finsupp.{u2, u1} α N _inst_1} {b : Finsupp.{u2, u1} α N _inst_1}, Iff (Finsupp.Lex.{u2, u1} α N _inst_1 r s a b) (Exists.{succ u2} α (fun (j : α) => And (forall (d : α), (r d j) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) d) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Finsupp.{u2, u1} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u2, u1} α N _inst_1) a d) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Finsupp.{u2, u1} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u2, u1} α N _inst_1) b d))) (s (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Finsupp.{u2, u1} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u2, u1} α N _inst_1) a j) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Finsupp.{u2, u1} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u2, u1} α N _inst_1) b j))))
-Case conversion may be inaccurate. Consider using '#align finsupp.lex_def Finsupp.lex_defₓ'. -/
 theorem lex_def {r : α → α → Prop} {s : N → N → Prop} {a b : α →₀ N} :
     Finsupp.Lex r s a b ↔ ∃ j, (∀ d, r d j → a d = b d) ∧ s (a j) (b j) :=
   Iff.rfl
 #align finsupp.lex_def Finsupp.lex_def
 
-/- warning: finsupp.lex_eq_inv_image_dfinsupp_lex -> Finsupp.lex_eq_invImage_dfinsupp_lex is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] (r : α -> α -> Prop) (s : N -> N -> Prop), Eq.{max (max (succ u1) (succ u2)) 1} ((Finsupp.{u1, u2} α N _inst_1) -> (Finsupp.{u1, u2} α N _inst_1) -> Prop) (Finsupp.Lex.{u1, u2} α N _inst_1 r s) (InvImage.{max (succ u1) (succ u2), succ (max u1 u2)} (Finsupp.{u1, u2} α N _inst_1) (Dfinsupp.{u1, u2} α (fun (i : α) => N) (fun (i : α) => _inst_1)) (Dfinsupp.Lex.{u1, u2} α (fun (a : α) => N) (fun (i : α) => _inst_1) r (fun (a : α) => s)) (Finsupp.toDfinsupp.{u1, u2} α N _inst_1))
-but is expected to have type
-  forall {α : Type.{u2}} {N : Type.{u1}} [_inst_1 : Zero.{u1} N] (r : α -> α -> Prop) (s : N -> N -> Prop), Eq.{max (succ u2) (succ u1)} ((Finsupp.{u2, u1} α N _inst_1) -> (Finsupp.{u2, u1} α N _inst_1) -> Prop) (Finsupp.Lex.{u2, u1} α N _inst_1 r s) (InvImage.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u2, u1} α N _inst_1) (Dfinsupp.{u2, u1} α (fun (i : α) => N) (fun (i : α) => _inst_1)) (Dfinsupp.Lex.{u2, u1} α (fun (a : α) => N) (fun (i : α) => _inst_1) r (fun (a : α) => s)) (Finsupp.toDfinsupp.{u2, u1} α N _inst_1))
-Case conversion may be inaccurate. Consider using '#align finsupp.lex_eq_inv_image_dfinsupp_lex Finsupp.lex_eq_invImage_dfinsupp_lexₓ'. -/
 theorem lex_eq_invImage_dfinsupp_lex (r : α → α → Prop) (s : N → N → Prop) :
     Finsupp.Lex r s = InvImage (Dfinsupp.Lex r fun a => s) toDfinsupp :=
   rfl
@@ -77,34 +59,16 @@ theorem lex_eq_invImage_dfinsupp_lex (r : α → α → Prop) (s : N → N → P
 instance [LT α] [LT N] : LT (Lex (α →₀ N)) :=
   ⟨fun f g => Finsupp.Lex (· < ·) (· < ·) (ofLex f) (ofLex g)⟩
 
-/- warning: finsupp.lex_lt_of_lt_of_preorder -> Finsupp.lex_lt_of_lt_of_preorder is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : Preorder.{u2} N] (r : α -> α -> Prop) [_inst_3 : IsStrictOrder.{u1} α r] {x : Finsupp.{u1, u2} α N _inst_1} {y : Finsupp.{u1, u2} α N _inst_1}, (LT.lt.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Preorder.toHasLt.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Finsupp.preorder.{u1, u2} α N _inst_1 _inst_2)) x y) -> (Exists.{succ u1} α (fun (i : α) => And (forall (j : α), (r j i) -> (And (LE.le.{u2} N (Preorder.toHasLe.{u2} N _inst_2) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) x j) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) y j)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N _inst_2) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) y j) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) x j)))) (LT.lt.{u2} N (Preorder.toHasLt.{u2} N _inst_2) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) x i) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) y i))))
-but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : Preorder.{u2} N] (r : α -> α -> Prop) [_inst_3 : IsStrictOrder.{u1} α r] {x : Finsupp.{u1, u2} α N _inst_1} {y : Finsupp.{u1, u2} α N _inst_1}, (LT.lt.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Preorder.toLT.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Finsupp.preorder.{u1, u2} α N _inst_1 _inst_2)) x y) -> (Exists.{succ u1} α (fun (i : α) => And (forall (j : α), (r j i) -> (And (LE.le.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) j) (Preorder.toLE.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) j) _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) x j) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) y j)) (LE.le.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) j) (Preorder.toLE.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) j) _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) y j) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) x j)))) (LT.lt.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) (Preorder.toLT.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) x i) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) y i))))
-Case conversion may be inaccurate. Consider using '#align finsupp.lex_lt_of_lt_of_preorder Finsupp.lex_lt_of_lt_of_preorderₓ'. -/
 theorem lex_lt_of_lt_of_preorder [Preorder N] (r) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y) :
     ∃ i, (∀ j, r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i :=
   Dfinsupp.lex_lt_of_lt_of_preorder r (id hlt : x.toDfinsupp < y.toDfinsupp)
 #align finsupp.lex_lt_of_lt_of_preorder Finsupp.lex_lt_of_lt_of_preorder
 
-/- warning: finsupp.lex_lt_of_lt -> Finsupp.lex_lt_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : PartialOrder.{u2} N] (r : α -> α -> Prop) [_inst_3 : IsStrictOrder.{u1} α r] {x : Finsupp.{u1, u2} α N _inst_1} {y : Finsupp.{u1, u2} α N _inst_1}, (LT.lt.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Preorder.toHasLt.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Finsupp.preorder.{u1, u2} α N _inst_1 (PartialOrder.toPreorder.{u2} N _inst_2))) x y) -> (Pi.Lex.{u1, u2} α (fun (ᾰ : α) => N) r (fun (i : α) => LT.lt.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N _inst_2))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) y))
-but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : PartialOrder.{u2} N] (r : α -> α -> Prop) [_inst_3 : IsStrictOrder.{u1} α r] {x : Finsupp.{u1, u2} α N _inst_1} {y : Finsupp.{u1, u2} α N _inst_1}, (LT.lt.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Preorder.toLT.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Finsupp.preorder.{u1, u2} α N _inst_1 (PartialOrder.toPreorder.{u2} N _inst_2))) x y) -> (Pi.Lex.{u1, u2} α (fun (ᾰ : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) ᾰ) r (fun {i : α} (x._@.Mathlib.Data.Finsupp.Lex._hyg.399 : (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) (x._@.Mathlib.Data.Finsupp.Lex._hyg.401 : (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) => LT.lt.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) (Preorder.toLT.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) (PartialOrder.toPreorder.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) _inst_2)) x._@.Mathlib.Data.Finsupp.Lex._hyg.399 x._@.Mathlib.Data.Finsupp.Lex._hyg.401) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) y))
-Case conversion may be inaccurate. Consider using '#align finsupp.lex_lt_of_lt Finsupp.lex_lt_of_ltₓ'. -/
 theorem lex_lt_of_lt [PartialOrder N] (r) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y) :
     Pi.Lex r (fun i => (· < ·)) x y :=
   Dfinsupp.lex_lt_of_lt r (id hlt : x.toDfinsupp < y.toDfinsupp)
 #align finsupp.lex_lt_of_lt Finsupp.lex_lt_of_lt
 
-/- warning: finsupp.lex.is_strict_order -> Finsupp.Lex.isStrictOrder is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N], IsStrictOrder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.Lex.hasLt.{u1, u2} α N _inst_1 (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))))
-but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N], IsStrictOrder.{max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.457 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (x._@.Mathlib.Data.Finsupp.Lex._hyg.459 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.instLTLexFinsupp.{u1, u2} α N _inst_1 (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))) x._@.Mathlib.Data.Finsupp.Lex._hyg.457 x._@.Mathlib.Data.Finsupp.Lex._hyg.459)
-Case conversion may be inaccurate. Consider using '#align finsupp.lex.is_strict_order Finsupp.Lex.isStrictOrderₓ'. -/
 instance Lex.isStrictOrder [LinearOrder α] [PartialOrder N] :
     IsStrictOrder (Lex (α →₀ N)) (· < ·) :=
   let i : IsStrictOrder (Lex (α → N)) (· < ·) := Pi.Lex.isStrictOrder
@@ -133,22 +97,10 @@ instance Lex.linearOrder [LinearOrder N] : LinearOrder (Lex (α →₀ N)) :=
 
 variable [PartialOrder N]
 
-/- warning: finsupp.to_lex_monotone -> Finsupp.toLex_monotone is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N], Monotone.{max u1 u2, max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.preorder.{u1, u2} α N _inst_1 (PartialOrder.toPreorder.{u2} N _inst_3)) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.Lex.partialOrder.{u1, u2} α N _inst_1 _inst_2 _inst_3)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Finsupp.{u1, u2} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Finsupp.{u1, u2} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1))) => (Finsupp.{u1, u2} α N _inst_1) -> (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Finsupp.{u1, u2} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1))) (toLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)))
-but is expected to have type
-  forall {α : Type.{u2}} {N : Type.{u1}} [_inst_1 : Zero.{u1} N] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : PartialOrder.{u1} N], Monotone.{max u2 u1, max u2 u1} (Finsupp.{u2, u1} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)) (Finsupp.preorder.{u2, u1} α N _inst_1 (PartialOrder.toPreorder.{u1} N _inst_3)) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)) (Finsupp.Lex.partialOrder.{u2, u1} α N _inst_1 _inst_2 _inst_3)) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Finsupp.{u2, u1} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1))) (Finsupp.{u2, u1} α N _inst_1) (fun (_x : Finsupp.{u2, u1} α N _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Finsupp.{u2, u1} α N _inst_1) => Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (Finsupp.{u2, u1} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1))) (toLex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)))
-Case conversion may be inaccurate. Consider using '#align finsupp.to_lex_monotone Finsupp.toLex_monotoneₓ'. -/
 theorem toLex_monotone : Monotone (@toLex (α →₀ N)) := fun a b h =>
   Dfinsupp.toLex_monotone (id h : ∀ i, ofLex (toDfinsupp a) i ≤ ofLex (toDfinsupp b) i)
 #align finsupp.to_lex_monotone Finsupp.toLex_monotone
 
-/- warning: finsupp.lt_of_forall_lt_of_lt -> Finsupp.lt_of_forall_lt_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N] (a : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (b : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (i : α), (forall (j : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) j i) -> (Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) => (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) -> (Finsupp.{u1, u2} α N _inst_1)) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) a) j) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) => (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) -> (Finsupp.{u1, u2} α N _inst_1)) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) b) j))) -> (LT.lt.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) => (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) -> (Finsupp.{u1, u2} α N _inst_1)) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) a) i) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) => (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) -> (Finsupp.{u1, u2} α N _inst_1)) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) b) i)) -> (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.Lex.hasLt.{u1, u2} α N _inst_1 (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))) a b)
-but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N] (a : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (b : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (i : α), (forall (j : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) j i) -> (Eq.{succ u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) j) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => Finsupp.{u1, u2} α N _inst_1) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) a) j) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => Finsupp.{u1, u2} α N _inst_1) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) b) j))) -> (LT.lt.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) (Preorder.toLT.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) (PartialOrder.toPreorder.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) _inst_3)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => Finsupp.{u1, u2} α N _inst_1) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) a) i) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => Finsupp.{u1, u2} α N _inst_1) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) b) i)) -> (LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.instLTLexFinsupp.{u1, u2} α N _inst_1 (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))) a b)
-Case conversion may be inaccurate. Consider using '#align finsupp.lt_of_forall_lt_of_lt Finsupp.lt_of_forall_lt_of_ltₓ'. -/
 theorem lt_of_forall_lt_of_lt (a b : Lex (α →₀ N)) (i : α) :
     (∀ j < i, ofLex a j = ofLex b j) → ofLex a i < ofLex b i → a < b := fun h1 h2 => ⟨i, h1, h2⟩
 #align finsupp.lt_of_forall_lt_of_lt Finsupp.lt_of_forall_lt_of_lt
@@ -171,24 +123,12 @@ section Left
 
 variable [CovariantClass N N (· + ·) (· < ·)]
 
-/- warning: finsupp.lex.covariant_class_lt_left -> Finsupp.Lex.covariantClass_lt_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (LT.lt.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
-but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.968 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.970 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.968 x._@.Mathlib.Data.Finsupp.Lex._hyg.970) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.983 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.985 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.983 x._@.Mathlib.Data.Finsupp.Lex._hyg.985)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1019 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1021 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1019 x._@.Mathlib.Data.Finsupp.Lex._hyg.1021) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1034 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1036 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1034 x._@.Mathlib.Data.Finsupp.Lex._hyg.1036)
-Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_lt_left Finsupp.Lex.covariantClass_lt_leftₓ'. -/
 instance Lex.covariantClass_lt_left :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (· + ·) (· < ·) :=
   ⟨fun f g h ⟨a, lta, ha⟩ =>
     ⟨a, fun j ja => congr_arg ((· + ·) _) (lta j ja), add_lt_add_left ha _⟩⟩
 #align finsupp.lex.covariant_class_lt_left Finsupp.Lex.covariantClass_lt_left
 
-/- warning: finsupp.lex.covariant_class_le_left -> Finsupp.Lex.covariantClass_le_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (LT.lt.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LE.le.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Preorder.toHasLe.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
-but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1123 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1125 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1123 x._@.Mathlib.Data.Finsupp.Lex._hyg.1125) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1138 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1140 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1138 x._@.Mathlib.Data.Finsupp.Lex._hyg.1140)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1174 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1176 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1174 x._@.Mathlib.Data.Finsupp.Lex._hyg.1176) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1189 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1191 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1189 x._@.Mathlib.Data.Finsupp.Lex._hyg.1191)
-Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_le_left Finsupp.Lex.covariantClass_le_leftₓ'. -/
 instance Lex.covariantClass_le_left :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (· + ·) (· ≤ ·) :=
   Add.to_covariantClass_left _
@@ -200,24 +140,12 @@ section Right
 
 variable [CovariantClass N N (Function.swap (· + ·)) (· < ·)]
 
-/- warning: finsupp.lex.covariant_class_lt_right -> Finsupp.Lex.covariantClass_lt_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Function.swap.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (fun (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) => Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
-but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1282 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1284 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1282 x._@.Mathlib.Data.Finsupp.Lex._hyg.1284)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1297 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1299 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1297 x._@.Mathlib.Data.Finsupp.Lex._hyg.1299)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1336 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1338 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1336 x._@.Mathlib.Data.Finsupp.Lex._hyg.1338)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1351 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1353 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1351 x._@.Mathlib.Data.Finsupp.Lex._hyg.1353)
-Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_lt_right Finsupp.Lex.covariantClass_lt_rightₓ'. -/
 instance Lex.covariantClass_lt_right :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (Function.swap (· + ·)) (· < ·) :=
   ⟨fun f g h ⟨a, lta, ha⟩ =>
     ⟨a, fun j ja => congr_arg (· + ofLex f j) (lta j ja), add_lt_add_right ha _⟩⟩
 #align finsupp.lex.covariant_class_lt_right Finsupp.Lex.covariantClass_lt_right
 
-/- warning: finsupp.lex.covariant_class_le_right -> Finsupp.Lex.covariantClass_le_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Function.swap.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (fun (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) => Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) (LE.le.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Preorder.toHasLe.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
-but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1457 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1459 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1457 x._@.Mathlib.Data.Finsupp.Lex._hyg.1459)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1472 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1474 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1472 x._@.Mathlib.Data.Finsupp.Lex._hyg.1474)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1511 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1513 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1511 x._@.Mathlib.Data.Finsupp.Lex._hyg.1513)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1526 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1528 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1526 x._@.Mathlib.Data.Finsupp.Lex._hyg.1528)
-Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_le_right Finsupp.Lex.covariantClass_le_rightₓ'. -/
 instance Lex.covariantClass_le_right :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (Function.swap (· + ·)) (· ≤ ·) :=
   Add.to_covariantClass_right _

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

@@ -137,7 +137,7 @@ variable [PartialOrder N]
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N], Monotone.{max u1 u2, max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.preorder.{u1, u2} α N _inst_1 (PartialOrder.toPreorder.{u2} N _inst_3)) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.Lex.partialOrder.{u1, u2} α N _inst_1 _inst_2 _inst_3)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Finsupp.{u1, u2} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Finsupp.{u1, u2} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1))) => (Finsupp.{u1, u2} α N _inst_1) -> (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Finsupp.{u1, u2} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1))) (toLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)))
 but is expected to have type
-  forall {α : Type.{u2}} {N : Type.{u1}} [_inst_1 : Zero.{u1} N] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : PartialOrder.{u1} N], Monotone.{max u2 u1, max u2 u1} (Finsupp.{u2, u1} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)) (Finsupp.preorder.{u2, u1} α N _inst_1 (PartialOrder.toPreorder.{u1} N _inst_3)) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)) (Finsupp.Lex.partialOrder.{u2, u1} α N _inst_1 _inst_2 _inst_3)) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Finsupp.{u2, u1} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1))) (Finsupp.{u2, u1} α N _inst_1) (fun (_x : Finsupp.{u2, u1} α N _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Finsupp.{u2, u1} α N _inst_1) => Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (Finsupp.{u2, u1} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1))) (toLex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)))
+  forall {α : Type.{u2}} {N : Type.{u1}} [_inst_1 : Zero.{u1} N] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : PartialOrder.{u1} N], Monotone.{max u2 u1, max u2 u1} (Finsupp.{u2, u1} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)) (Finsupp.preorder.{u2, u1} α N _inst_1 (PartialOrder.toPreorder.{u1} N _inst_3)) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)) (Finsupp.Lex.partialOrder.{u2, u1} α N _inst_1 _inst_2 _inst_3)) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Finsupp.{u2, u1} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1))) (Finsupp.{u2, u1} α N _inst_1) (fun (_x : Finsupp.{u2, u1} α N _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Finsupp.{u2, u1} α N _inst_1) => Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (Finsupp.{u2, u1} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1))) (toLex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)))
 Case conversion may be inaccurate. Consider using '#align finsupp.to_lex_monotone Finsupp.toLex_monotoneₓ'. -/
 theorem toLex_monotone : Monotone (@toLex (α →₀ N)) := fun a b h =>
   Dfinsupp.toLex_monotone (id h : ∀ i, ofLex (toDfinsupp a) i ≤ ofLex (toDfinsupp b) i)
@@ -147,7 +147,7 @@ theorem toLex_monotone : Monotone (@toLex (α →₀ N)) := fun a b h =>
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N] (a : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (b : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (i : α), (forall (j : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) j i) -> (Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) => (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) -> (Finsupp.{u1, u2} α N _inst_1)) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) a) j) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) => (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) -> (Finsupp.{u1, u2} α N _inst_1)) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) b) j))) -> (LT.lt.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) => (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) -> (Finsupp.{u1, u2} α N _inst_1)) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) a) i) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) => (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) -> (Finsupp.{u1, u2} α N _inst_1)) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) b) i)) -> (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.Lex.hasLt.{u1, u2} α N _inst_1 (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))) a b)
 but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N] (a : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (b : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (i : α), (forall (j : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) j i) -> (Eq.{succ u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) j) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => Finsupp.{u1, u2} α N _inst_1) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) a) j) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => Finsupp.{u1, u2} α N _inst_1) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) b) j))) -> (LT.lt.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) (Preorder.toLT.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) (PartialOrder.toPreorder.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) _inst_3)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => Finsupp.{u1, u2} α N _inst_1) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) a) i) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => Finsupp.{u1, u2} α N _inst_1) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) b) i)) -> (LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.instLTLexFinsupp.{u1, u2} α N _inst_1 (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))) a b)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N] (a : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (b : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (i : α), (forall (j : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) j i) -> (Eq.{succ u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) j) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => Finsupp.{u1, u2} α N _inst_1) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) a) j) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => Finsupp.{u1, u2} α N _inst_1) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) b) j))) -> (LT.lt.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) (Preorder.toLT.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) (PartialOrder.toPreorder.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) _inst_3)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => Finsupp.{u1, u2} α N _inst_1) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) a) i) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => Finsupp.{u1, u2} α N _inst_1) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) b) i)) -> (LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.instLTLexFinsupp.{u1, u2} α N _inst_1 (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))) a b)
 Case conversion may be inaccurate. Consider using '#align finsupp.lt_of_forall_lt_of_lt Finsupp.lt_of_forall_lt_of_ltₓ'. -/
 theorem lt_of_forall_lt_of_lt (a b : Lex (α →₀ N)) (i : α) :
     (∀ j < i, ofLex a j = ofLex b j) → ofLex a i < ofLex b i → a < b := fun h1 h2 => ⟨i, h1, h2⟩

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

@@ -77,23 +77,31 @@ theorem lex_eq_invImage_dfinsupp_lex (r : α → α → Prop) (s : N → N → P
 instance [LT α] [LT N] : LT (Lex (α →₀ N)) :=
   ⟨fun f g => Finsupp.Lex (· < ·) (· < ·) (ofLex f) (ofLex g)⟩
 
-#print Finsupp.lex_lt_of_lt_of_preorder /-
+/- warning: finsupp.lex_lt_of_lt_of_preorder -> Finsupp.lex_lt_of_lt_of_preorder is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : Preorder.{u2} N] (r : α -> α -> Prop) [_inst_3 : IsStrictOrder.{u1} α r] {x : Finsupp.{u1, u2} α N _inst_1} {y : Finsupp.{u1, u2} α N _inst_1}, (LT.lt.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Preorder.toHasLt.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Finsupp.preorder.{u1, u2} α N _inst_1 _inst_2)) x y) -> (Exists.{succ u1} α (fun (i : α) => And (forall (j : α), (r j i) -> (And (LE.le.{u2} N (Preorder.toHasLe.{u2} N _inst_2) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) x j) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) y j)) (LE.le.{u2} N (Preorder.toHasLe.{u2} N _inst_2) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) y j) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) x j)))) (LT.lt.{u2} N (Preorder.toHasLt.{u2} N _inst_2) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) x i) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) y i))))
+but is expected to have type
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : Preorder.{u2} N] (r : α -> α -> Prop) [_inst_3 : IsStrictOrder.{u1} α r] {x : Finsupp.{u1, u2} α N _inst_1} {y : Finsupp.{u1, u2} α N _inst_1}, (LT.lt.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Preorder.toLT.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Finsupp.preorder.{u1, u2} α N _inst_1 _inst_2)) x y) -> (Exists.{succ u1} α (fun (i : α) => And (forall (j : α), (r j i) -> (And (LE.le.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) j) (Preorder.toLE.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) j) _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) x j) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) y j)) (LE.le.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) j) (Preorder.toLE.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) j) _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) y j) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) x j)))) (LT.lt.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) (Preorder.toLT.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) x i) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) y i))))
+Case conversion may be inaccurate. Consider using '#align finsupp.lex_lt_of_lt_of_preorder Finsupp.lex_lt_of_lt_of_preorderₓ'. -/
 theorem lex_lt_of_lt_of_preorder [Preorder N] (r) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y) :
     ∃ i, (∀ j, r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i :=
   Dfinsupp.lex_lt_of_lt_of_preorder r (id hlt : x.toDfinsupp < y.toDfinsupp)
 #align finsupp.lex_lt_of_lt_of_preorder Finsupp.lex_lt_of_lt_of_preorder
--/
 
-#print Finsupp.lex_lt_of_lt /-
+/- warning: finsupp.lex_lt_of_lt -> Finsupp.lex_lt_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : PartialOrder.{u2} N] (r : α -> α -> Prop) [_inst_3 : IsStrictOrder.{u1} α r] {x : Finsupp.{u1, u2} α N _inst_1} {y : Finsupp.{u1, u2} α N _inst_1}, (LT.lt.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Preorder.toHasLt.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Finsupp.preorder.{u1, u2} α N _inst_1 (PartialOrder.toPreorder.{u2} N _inst_2))) x y) -> (Pi.Lex.{u1, u2} α (fun (ᾰ : α) => N) r (fun (i : α) => LT.lt.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N _inst_2))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) y))
+but is expected to have type
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : PartialOrder.{u2} N] (r : α -> α -> Prop) [_inst_3 : IsStrictOrder.{u1} α r] {x : Finsupp.{u1, u2} α N _inst_1} {y : Finsupp.{u1, u2} α N _inst_1}, (LT.lt.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Preorder.toLT.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Finsupp.preorder.{u1, u2} α N _inst_1 (PartialOrder.toPreorder.{u2} N _inst_2))) x y) -> (Pi.Lex.{u1, u2} α (fun (ᾰ : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) ᾰ) r (fun {i : α} (x._@.Mathlib.Data.Finsupp.Lex._hyg.399 : (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) (x._@.Mathlib.Data.Finsupp.Lex._hyg.401 : (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) => LT.lt.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) (Preorder.toLT.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) (PartialOrder.toPreorder.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) _inst_2)) x._@.Mathlib.Data.Finsupp.Lex._hyg.399 x._@.Mathlib.Data.Finsupp.Lex._hyg.401) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) y))
+Case conversion may be inaccurate. Consider using '#align finsupp.lex_lt_of_lt Finsupp.lex_lt_of_ltₓ'. -/
 theorem lex_lt_of_lt [PartialOrder N] (r) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y) :
     Pi.Lex r (fun i => (· < ·)) x y :=
   Dfinsupp.lex_lt_of_lt r (id hlt : x.toDfinsupp < y.toDfinsupp)
 #align finsupp.lex_lt_of_lt Finsupp.lex_lt_of_lt
--/
 
 /- warning: finsupp.lex.is_strict_order -> Finsupp.Lex.isStrictOrder is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N], IsStrictOrder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.Lex.hasLt.{u1, u2} α N _inst_1 (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))))
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N], IsStrictOrder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.Lex.hasLt.{u1, u2} α N _inst_1 (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))))
 but is expected to have type
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N], IsStrictOrder.{max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.457 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (x._@.Mathlib.Data.Finsupp.Lex._hyg.459 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.instLTLexFinsupp.{u1, u2} α N _inst_1 (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))) x._@.Mathlib.Data.Finsupp.Lex._hyg.457 x._@.Mathlib.Data.Finsupp.Lex._hyg.459)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.is_strict_order Finsupp.Lex.isStrictOrderₓ'. -/
@@ -135,11 +143,15 @@ theorem toLex_monotone : Monotone (@toLex (α →₀ N)) := fun a b h =>
   Dfinsupp.toLex_monotone (id h : ∀ i, ofLex (toDfinsupp a) i ≤ ofLex (toDfinsupp b) i)
 #align finsupp.to_lex_monotone Finsupp.toLex_monotone
 
-#print Finsupp.lt_of_forall_lt_of_lt /-
+/- warning: finsupp.lt_of_forall_lt_of_lt -> Finsupp.lt_of_forall_lt_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N] (a : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (b : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (i : α), (forall (j : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) j i) -> (Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) => (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) -> (Finsupp.{u1, u2} α N _inst_1)) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) a) j) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) => (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) -> (Finsupp.{u1, u2} α N _inst_1)) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) b) j))) -> (LT.lt.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) => (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) -> (Finsupp.{u1, u2} α N _inst_1)) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) a) i) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) => (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) -> (Finsupp.{u1, u2} α N _inst_1)) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) b) i)) -> (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.Lex.hasLt.{u1, u2} α N _inst_1 (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))) a b)
+but is expected to have type
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N] (a : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (b : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (i : α), (forall (j : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) j i) -> (Eq.{succ u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) j) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => Finsupp.{u1, u2} α N _inst_1) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) a) j) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => Finsupp.{u1, u2} α N _inst_1) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) b) j))) -> (LT.lt.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) (Preorder.toLT.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) (PartialOrder.toPreorder.{u2} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) i) _inst_3)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => Finsupp.{u1, u2} α N _inst_1) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) a) i) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Finsupp.{u1, u2} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u1, u2} α N _inst_1) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (fun (_x : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) => Finsupp.{u1, u2} α N _inst_1) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.{u1, u2} α N _inst_1)) (ofLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) b) i)) -> (LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.instLTLexFinsupp.{u1, u2} α N _inst_1 (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))) a b)
+Case conversion may be inaccurate. Consider using '#align finsupp.lt_of_forall_lt_of_lt Finsupp.lt_of_forall_lt_of_ltₓ'. -/
 theorem lt_of_forall_lt_of_lt (a b : Lex (α →₀ N)) (i : α) :
     (∀ j < i, ofLex a j = ofLex b j) → ofLex a i < ofLex b i → a < b := fun h1 h2 => ⟨i, h1, h2⟩
 #align finsupp.lt_of_forall_lt_of_lt Finsupp.lt_of_forall_lt_of_lt
--/
 
 end NHasZero
 
@@ -161,7 +173,7 @@ variable [CovariantClass N N (· + ·) (· < ·)]
 
 /- warning: finsupp.lex.covariant_class_lt_left -> Finsupp.Lex.covariantClass_lt_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (LT.lt.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.968 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.970 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.968 x._@.Mathlib.Data.Finsupp.Lex._hyg.970) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.983 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.985 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.983 x._@.Mathlib.Data.Finsupp.Lex._hyg.985)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1019 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1021 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1019 x._@.Mathlib.Data.Finsupp.Lex._hyg.1021) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1034 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1036 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1034 x._@.Mathlib.Data.Finsupp.Lex._hyg.1036)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_lt_left Finsupp.Lex.covariantClass_lt_leftₓ'. -/
@@ -173,7 +185,7 @@ instance Lex.covariantClass_lt_left :
 
 /- warning: finsupp.lex.covariant_class_le_left -> Finsupp.Lex.covariantClass_le_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LE.le.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (LT.lt.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LE.le.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Preorder.toHasLe.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1123 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1125 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1123 x._@.Mathlib.Data.Finsupp.Lex._hyg.1125) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1138 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1140 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1138 x._@.Mathlib.Data.Finsupp.Lex._hyg.1140)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1174 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1176 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1174 x._@.Mathlib.Data.Finsupp.Lex._hyg.1176) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1189 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1191 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1189 x._@.Mathlib.Data.Finsupp.Lex._hyg.1191)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_le_left Finsupp.Lex.covariantClass_le_leftₓ'. -/
@@ -190,7 +202,7 @@ variable [CovariantClass N N (Function.swap (· + ·)) (· < ·)]
 
 /- warning: finsupp.lex.covariant_class_lt_right -> Finsupp.Lex.covariantClass_lt_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Function.swap.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (fun (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) => Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Function.swap.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (fun (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) => Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1282 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1284 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1282 x._@.Mathlib.Data.Finsupp.Lex._hyg.1284)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1297 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1299 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1297 x._@.Mathlib.Data.Finsupp.Lex._hyg.1299)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1336 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1338 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1336 x._@.Mathlib.Data.Finsupp.Lex._hyg.1338)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1351 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1353 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1351 x._@.Mathlib.Data.Finsupp.Lex._hyg.1353)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_lt_right Finsupp.Lex.covariantClass_lt_rightₓ'. -/
@@ -202,7 +214,7 @@ instance Lex.covariantClass_lt_right :
 
 /- warning: finsupp.lex.covariant_class_le_right -> Finsupp.Lex.covariantClass_le_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Function.swap.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (fun (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) => Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) (LE.le.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Function.swap.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (fun (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) => Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) (LE.le.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Preorder.toHasLe.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1457 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1459 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1457 x._@.Mathlib.Data.Finsupp.Lex._hyg.1459)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1472 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1474 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1472 x._@.Mathlib.Data.Finsupp.Lex._hyg.1474)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1511 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1513 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1511 x._@.Mathlib.Data.Finsupp.Lex._hyg.1513)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1526 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1528 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1526 x._@.Mathlib.Data.Finsupp.Lex._hyg.1528)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_le_right Finsupp.Lex.covariantClass_le_rightₓ'. -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/728baa2f54e6062c5879a3e397ac6bac323e506f

@@ -163,7 +163,7 @@ variable [CovariantClass N N (· + ·) (· < ·)]
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.966 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.968 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.966 x._@.Mathlib.Data.Finsupp.Lex._hyg.968) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.981 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.983 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.981 x._@.Mathlib.Data.Finsupp.Lex._hyg.983)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1017 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1019 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1017 x._@.Mathlib.Data.Finsupp.Lex._hyg.1019) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1032 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1034 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1032 x._@.Mathlib.Data.Finsupp.Lex._hyg.1034)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.968 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.970 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.968 x._@.Mathlib.Data.Finsupp.Lex._hyg.970) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.983 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.985 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.983 x._@.Mathlib.Data.Finsupp.Lex._hyg.985)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1019 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1021 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1019 x._@.Mathlib.Data.Finsupp.Lex._hyg.1021) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1034 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1036 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1034 x._@.Mathlib.Data.Finsupp.Lex._hyg.1036)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_lt_left Finsupp.Lex.covariantClass_lt_leftₓ'. -/
 instance Lex.covariantClass_lt_left :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (· + ·) (· < ·) :=
@@ -175,7 +175,7 @@ instance Lex.covariantClass_lt_left :
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LE.le.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1121 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1123 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1121 x._@.Mathlib.Data.Finsupp.Lex._hyg.1123) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1136 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1138 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1136 x._@.Mathlib.Data.Finsupp.Lex._hyg.1138)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1172 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1174 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1172 x._@.Mathlib.Data.Finsupp.Lex._hyg.1174) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1187 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1189 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1187 x._@.Mathlib.Data.Finsupp.Lex._hyg.1189)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1123 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1125 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1123 x._@.Mathlib.Data.Finsupp.Lex._hyg.1125) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1138 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1140 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1138 x._@.Mathlib.Data.Finsupp.Lex._hyg.1140)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1174 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1176 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1174 x._@.Mathlib.Data.Finsupp.Lex._hyg.1176) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1189 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1191 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1189 x._@.Mathlib.Data.Finsupp.Lex._hyg.1191)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_le_left Finsupp.Lex.covariantClass_le_leftₓ'. -/
 instance Lex.covariantClass_le_left :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (· + ·) (· ≤ ·) :=
@@ -192,7 +192,7 @@ variable [CovariantClass N N (Function.swap (· + ·)) (· < ·)]
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Function.swap.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (fun (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) => Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1280 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1282 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1280 x._@.Mathlib.Data.Finsupp.Lex._hyg.1282)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1295 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1297 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1295 x._@.Mathlib.Data.Finsupp.Lex._hyg.1297)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1334 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1336 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1334 x._@.Mathlib.Data.Finsupp.Lex._hyg.1336)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1349 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1351 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1349 x._@.Mathlib.Data.Finsupp.Lex._hyg.1351)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1282 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1284 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1282 x._@.Mathlib.Data.Finsupp.Lex._hyg.1284)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1297 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1299 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1297 x._@.Mathlib.Data.Finsupp.Lex._hyg.1299)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1336 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1338 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1336 x._@.Mathlib.Data.Finsupp.Lex._hyg.1338)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1351 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1353 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1351 x._@.Mathlib.Data.Finsupp.Lex._hyg.1353)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_lt_right Finsupp.Lex.covariantClass_lt_rightₓ'. -/
 instance Lex.covariantClass_lt_right :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (Function.swap (· + ·)) (· < ·) :=
@@ -204,7 +204,7 @@ instance Lex.covariantClass_lt_right :
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Function.swap.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (fun (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) => Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) (LE.le.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1455 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1457 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1455 x._@.Mathlib.Data.Finsupp.Lex._hyg.1457)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1470 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1472 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1470 x._@.Mathlib.Data.Finsupp.Lex._hyg.1472)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1509 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1511 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1509 x._@.Mathlib.Data.Finsupp.Lex._hyg.1511)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1524 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1526 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1524 x._@.Mathlib.Data.Finsupp.Lex._hyg.1526)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1457 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1459 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1457 x._@.Mathlib.Data.Finsupp.Lex._hyg.1459)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1472 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1474 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1472 x._@.Mathlib.Data.Finsupp.Lex._hyg.1474)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1511 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1513 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1511 x._@.Mathlib.Data.Finsupp.Lex._hyg.1513)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1526 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1528 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1526 x._@.Mathlib.Data.Finsupp.Lex._hyg.1528)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_le_right Finsupp.Lex.covariantClass_le_rightₓ'. -/
 instance Lex.covariantClass_le_right :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (Function.swap (· + ·)) (· ≤ ·) :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/02ba8949f486ebecf93fe7460f1ed0564b5e442c

@@ -67,7 +67,7 @@ theorem lex_def {r : α → α → Prop} {s : N → N → Prop} {a b : α →₀
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] (r : α -> α -> Prop) (s : N -> N -> Prop), Eq.{max (max (succ u1) (succ u2)) 1} ((Finsupp.{u1, u2} α N _inst_1) -> (Finsupp.{u1, u2} α N _inst_1) -> Prop) (Finsupp.Lex.{u1, u2} α N _inst_1 r s) (InvImage.{max (succ u1) (succ u2), succ (max u1 u2)} (Finsupp.{u1, u2} α N _inst_1) (Dfinsupp.{u1, u2} α (fun (i : α) => N) (fun (i : α) => _inst_1)) (Dfinsupp.Lex.{u1, u2} α (fun (a : α) => N) (fun (i : α) => _inst_1) r (fun (a : α) => s)) (Finsupp.toDfinsupp.{u1, u2} α N _inst_1))
 but is expected to have type
-  forall {α : Type.{u2}} {N : Type.{u1}} [_inst_1 : Zero.{u1} N] (r : α -> α -> Prop) (s : N -> N -> Prop), Eq.{max (succ u2) (succ u1)} ((Finsupp.{u2, u1} α N _inst_1) -> (Finsupp.{u2, u1} α N _inst_1) -> Prop) (Finsupp.Lex.{u2, u1} α N _inst_1 r s) (InvImage.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u2, u1} α N _inst_1) (Dfinsupp.{u2, u1} α (fun (i : α) => N) (fun (i : α) => _inst_1)) (Dfinsupp.Lex.{u2, u1} α (fun {a : α} => N) (fun (i : α) => _inst_1) r (fun {a : α} => s)) (Finsupp.toDfinsupp.{u2, u1} α N _inst_1))
+  forall {α : Type.{u2}} {N : Type.{u1}} [_inst_1 : Zero.{u1} N] (r : α -> α -> Prop) (s : N -> N -> Prop), Eq.{max (succ u2) (succ u1)} ((Finsupp.{u2, u1} α N _inst_1) -> (Finsupp.{u2, u1} α N _inst_1) -> Prop) (Finsupp.Lex.{u2, u1} α N _inst_1 r s) (InvImage.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u2, u1} α N _inst_1) (Dfinsupp.{u2, u1} α (fun (i : α) => N) (fun (i : α) => _inst_1)) (Dfinsupp.Lex.{u2, u1} α (fun (a : α) => N) (fun (i : α) => _inst_1) r (fun (a : α) => s)) (Finsupp.toDfinsupp.{u2, u1} α N _inst_1))
 Case conversion may be inaccurate. Consider using '#align finsupp.lex_eq_inv_image_dfinsupp_lex Finsupp.lex_eq_invImage_dfinsupp_lexₓ'. -/
 theorem lex_eq_invImage_dfinsupp_lex (r : α → α → Prop) (s : N → N → Prop) :
     Finsupp.Lex r s = InvImage (Dfinsupp.Lex r fun a => s) toDfinsupp :=
@@ -95,7 +95,7 @@ theorem lex_lt_of_lt [PartialOrder N] (r) [IsStrictOrder α r] {x y : α →₀
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N], IsStrictOrder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.Lex.hasLt.{u1, u2} α N _inst_1 (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))))
 but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N], IsStrictOrder.{max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.454 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (x._@.Mathlib.Data.Finsupp.Lex._hyg.456 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.instLTLexFinsupp.{u1, u2} α N _inst_1 (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))) x._@.Mathlib.Data.Finsupp.Lex._hyg.454 x._@.Mathlib.Data.Finsupp.Lex._hyg.456)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N], IsStrictOrder.{max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.457 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (x._@.Mathlib.Data.Finsupp.Lex._hyg.459 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.instLTLexFinsupp.{u1, u2} α N _inst_1 (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))) x._@.Mathlib.Data.Finsupp.Lex._hyg.457 x._@.Mathlib.Data.Finsupp.Lex._hyg.459)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.is_strict_order Finsupp.Lex.isStrictOrderₓ'. -/
 instance Lex.isStrictOrder [LinearOrder α] [PartialOrder N] :
     IsStrictOrder (Lex (α →₀ N)) (· < ·) :=
@@ -163,7 +163,7 @@ variable [CovariantClass N N (· + ·) (· < ·)]
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.963 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.965 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.963 x._@.Mathlib.Data.Finsupp.Lex._hyg.965) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.978 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.980 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.978 x._@.Mathlib.Data.Finsupp.Lex._hyg.980)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1014 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1016 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1014 x._@.Mathlib.Data.Finsupp.Lex._hyg.1016) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1029 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1031 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1029 x._@.Mathlib.Data.Finsupp.Lex._hyg.1031)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.966 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.968 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.966 x._@.Mathlib.Data.Finsupp.Lex._hyg.968) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.981 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.983 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.981 x._@.Mathlib.Data.Finsupp.Lex._hyg.983)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1017 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1019 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1017 x._@.Mathlib.Data.Finsupp.Lex._hyg.1019) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1032 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1034 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1032 x._@.Mathlib.Data.Finsupp.Lex._hyg.1034)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_lt_left Finsupp.Lex.covariantClass_lt_leftₓ'. -/
 instance Lex.covariantClass_lt_left :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (· + ·) (· < ·) :=
@@ -175,7 +175,7 @@ instance Lex.covariantClass_lt_left :
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LE.le.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1118 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1120 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1118 x._@.Mathlib.Data.Finsupp.Lex._hyg.1120) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1133 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1135 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1133 x._@.Mathlib.Data.Finsupp.Lex._hyg.1135)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1169 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1171 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1169 x._@.Mathlib.Data.Finsupp.Lex._hyg.1171) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1184 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1186 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1184 x._@.Mathlib.Data.Finsupp.Lex._hyg.1186)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1121 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1123 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1121 x._@.Mathlib.Data.Finsupp.Lex._hyg.1123) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1136 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1138 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1136 x._@.Mathlib.Data.Finsupp.Lex._hyg.1138)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1172 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1174 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1172 x._@.Mathlib.Data.Finsupp.Lex._hyg.1174) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1187 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1189 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1187 x._@.Mathlib.Data.Finsupp.Lex._hyg.1189)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_le_left Finsupp.Lex.covariantClass_le_leftₓ'. -/
 instance Lex.covariantClass_le_left :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (· + ·) (· ≤ ·) :=
@@ -192,7 +192,7 @@ variable [CovariantClass N N (Function.swap (· + ·)) (· < ·)]
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Function.swap.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (fun (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) => Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1277 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1279 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1277 x._@.Mathlib.Data.Finsupp.Lex._hyg.1279)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1292 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1294 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1292 x._@.Mathlib.Data.Finsupp.Lex._hyg.1294)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1331 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1333 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1331 x._@.Mathlib.Data.Finsupp.Lex._hyg.1333)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1346 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1348 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1346 x._@.Mathlib.Data.Finsupp.Lex._hyg.1348)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1280 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1282 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1280 x._@.Mathlib.Data.Finsupp.Lex._hyg.1282)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1295 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1297 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1295 x._@.Mathlib.Data.Finsupp.Lex._hyg.1297)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1334 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1336 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1334 x._@.Mathlib.Data.Finsupp.Lex._hyg.1336)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1349 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1351 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1349 x._@.Mathlib.Data.Finsupp.Lex._hyg.1351)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_lt_right Finsupp.Lex.covariantClass_lt_rightₓ'. -/
 instance Lex.covariantClass_lt_right :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (Function.swap (· + ·)) (· < ·) :=
@@ -204,7 +204,7 @@ instance Lex.covariantClass_lt_right :
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Function.swap.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (fun (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) => Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) (LE.le.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1452 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1454 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1452 x._@.Mathlib.Data.Finsupp.Lex._hyg.1454)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1467 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1469 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1467 x._@.Mathlib.Data.Finsupp.Lex._hyg.1469)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1506 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1508 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1506 x._@.Mathlib.Data.Finsupp.Lex._hyg.1508)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1521 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1523 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1521 x._@.Mathlib.Data.Finsupp.Lex._hyg.1523)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1455 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1457 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1455 x._@.Mathlib.Data.Finsupp.Lex._hyg.1457)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1470 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1472 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1470 x._@.Mathlib.Data.Finsupp.Lex._hyg.1472)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1509 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1511 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1509 x._@.Mathlib.Data.Finsupp.Lex._hyg.1511)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1524 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1526 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1524 x._@.Mathlib.Data.Finsupp.Lex._hyg.1526)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_le_right Finsupp.Lex.covariantClass_le_rightₓ'. -/
 instance Lex.covariantClass_le_right :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (Function.swap (· + ·)) (· ≤ ·) :=

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

@@ -95,7 +95,7 @@ theorem lex_lt_of_lt [PartialOrder N] (r) [IsStrictOrder α r] {x y : α →₀
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N], IsStrictOrder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.Lex.hasLt.{u1, u2} α N _inst_1 (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))))
 but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N], IsStrictOrder.{max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.436 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (x._@.Mathlib.Data.Finsupp.Lex._hyg.438 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.instLTLexFinsupp.{u1, u2} α N _inst_1 (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))) x._@.Mathlib.Data.Finsupp.Lex._hyg.436 x._@.Mathlib.Data.Finsupp.Lex._hyg.438)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N], IsStrictOrder.{max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.454 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (x._@.Mathlib.Data.Finsupp.Lex._hyg.456 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.instLTLexFinsupp.{u1, u2} α N _inst_1 (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N _inst_3))) x._@.Mathlib.Data.Finsupp.Lex._hyg.454 x._@.Mathlib.Data.Finsupp.Lex._hyg.456)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.is_strict_order Finsupp.Lex.isStrictOrderₓ'. -/
 instance Lex.isStrictOrder [LinearOrder α] [PartialOrder N] :
     IsStrictOrder (Lex (α →₀ N)) (· < ·) :=
@@ -129,7 +129,7 @@ variable [PartialOrder N]
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PartialOrder.{u2} N], Monotone.{max u1 u2, max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.preorder.{u1, u2} α N _inst_1 (PartialOrder.toPreorder.{u2} N _inst_3)) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)) (Finsupp.Lex.partialOrder.{u1, u2} α N _inst_1 _inst_2 _inst_3)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Finsupp.{u1, u2} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Finsupp.{u1, u2} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1))) => (Finsupp.{u1, u2} α N _inst_1) -> (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Finsupp.{u1, u2} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1))) (toLex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1)))
 but is expected to have type
-  forall {α : Type.{u2}} {N : Type.{u1}} [_inst_1 : Zero.{u1} N] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : PartialOrder.{u1} N], Monotone.{max u2 u1, max u2 u1} (Finsupp.{u2, u1} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)) (Finsupp.preorder.{u2, u1} α N _inst_1 (PartialOrder.toPreorder.{u1} N _inst_3)) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)) (Finsupp.Lex.partialOrder.{u2, u1} α N _inst_1 _inst_2 _inst_3)) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Finsupp.{u2, u1} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1))) (Finsupp.{u2, u1} α N _inst_1) (fun (_x : Finsupp.{u2, u1} α N _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Finsupp.{u2, u1} α N _inst_1) => Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (Finsupp.{u2, u1} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1))) (toLex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)))
+  forall {α : Type.{u2}} {N : Type.{u1}} [_inst_1 : Zero.{u1} N] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : PartialOrder.{u1} N], Monotone.{max u2 u1, max u2 u1} (Finsupp.{u2, u1} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)) (Finsupp.preorder.{u2, u1} α N _inst_1 (PartialOrder.toPreorder.{u1} N _inst_3)) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)) (Finsupp.Lex.partialOrder.{u2, u1} α N _inst_1 _inst_2 _inst_3)) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Finsupp.{u2, u1} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1))) (Finsupp.{u2, u1} α N _inst_1) (fun (_x : Finsupp.{u2, u1} α N _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Finsupp.{u2, u1} α N _inst_1) => Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (Finsupp.{u2, u1} α N _inst_1) (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1))) (toLex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_1)))
 Case conversion may be inaccurate. Consider using '#align finsupp.to_lex_monotone Finsupp.toLex_monotoneₓ'. -/
 theorem toLex_monotone : Monotone (@toLex (α →₀ N)) := fun a b h =>
   Dfinsupp.toLex_monotone (id h : ∀ i, ofLex (toDfinsupp a) i ≤ ofLex (toDfinsupp b) i)
@@ -163,7 +163,7 @@ variable [CovariantClass N N (· + ·) (· < ·)]
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.927 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.929 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.927 x._@.Mathlib.Data.Finsupp.Lex._hyg.929) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.942 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.944 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.942 x._@.Mathlib.Data.Finsupp.Lex._hyg.944)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.978 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.980 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.978 x._@.Mathlib.Data.Finsupp.Lex._hyg.980) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.993 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.995 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.993 x._@.Mathlib.Data.Finsupp.Lex._hyg.995)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.963 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.965 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.963 x._@.Mathlib.Data.Finsupp.Lex._hyg.965) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.978 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.980 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.978 x._@.Mathlib.Data.Finsupp.Lex._hyg.980)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1014 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1016 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1014 x._@.Mathlib.Data.Finsupp.Lex._hyg.1016) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1029 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1031 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1029 x._@.Mathlib.Data.Finsupp.Lex._hyg.1031)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_lt_left Finsupp.Lex.covariantClass_lt_leftₓ'. -/
 instance Lex.covariantClass_lt_left :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (· + ·) (· < ·) :=
@@ -175,7 +175,7 @@ instance Lex.covariantClass_lt_left :
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LE.le.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1082 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1084 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1082 x._@.Mathlib.Data.Finsupp.Lex._hyg.1084) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1097 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1099 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1097 x._@.Mathlib.Data.Finsupp.Lex._hyg.1099)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1133 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1135 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1133 x._@.Mathlib.Data.Finsupp.Lex._hyg.1135) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1148 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1150 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1148 x._@.Mathlib.Data.Finsupp.Lex._hyg.1150)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1118 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1120 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1118 x._@.Mathlib.Data.Finsupp.Lex._hyg.1120) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1133 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1135 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1133 x._@.Mathlib.Data.Finsupp.Lex._hyg.1135)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1169 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1171 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1169 x._@.Mathlib.Data.Finsupp.Lex._hyg.1171) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1184 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1186 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1184 x._@.Mathlib.Data.Finsupp.Lex._hyg.1186)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_le_left Finsupp.Lex.covariantClass_le_leftₓ'. -/
 instance Lex.covariantClass_le_left :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (· + ·) (· ≤ ·) :=
@@ -192,7 +192,7 @@ variable [CovariantClass N N (Function.swap (· + ·)) (· < ·)]
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Function.swap.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (fun (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) => Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1241 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1243 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1241 x._@.Mathlib.Data.Finsupp.Lex._hyg.1243)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1256 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1258 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1256 x._@.Mathlib.Data.Finsupp.Lex._hyg.1258)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1295 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1297 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1295 x._@.Mathlib.Data.Finsupp.Lex._hyg.1297)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1310 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1312 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1310 x._@.Mathlib.Data.Finsupp.Lex._hyg.1312)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1277 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1279 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1277 x._@.Mathlib.Data.Finsupp.Lex._hyg.1279)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1292 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1294 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1292 x._@.Mathlib.Data.Finsupp.Lex._hyg.1294)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1331 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1333 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1331 x._@.Mathlib.Data.Finsupp.Lex._hyg.1333)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1346 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1348 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1346 x._@.Mathlib.Data.Finsupp.Lex._hyg.1348)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_lt_right Finsupp.Lex.covariantClass_lt_rightₓ'. -/
 instance Lex.covariantClass_lt_right :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (Function.swap (· + ·)) (· < ·) :=
@@ -204,7 +204,7 @@ instance Lex.covariantClass_lt_right :
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Function.swap.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (fun (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) => Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) (LE.le.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1414 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1416 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1414 x._@.Mathlib.Data.Finsupp.Lex._hyg.1416)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1429 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1431 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1429 x._@.Mathlib.Data.Finsupp.Lex._hyg.1431)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1468 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1470 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1468 x._@.Mathlib.Data.Finsupp.Lex._hyg.1470)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1483 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1485 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1483 x._@.Mathlib.Data.Finsupp.Lex._hyg.1485)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1452 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1454 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1452 x._@.Mathlib.Data.Finsupp.Lex._hyg.1454)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1467 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1469 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1467 x._@.Mathlib.Data.Finsupp.Lex._hyg.1469)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1506 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1508 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1506 x._@.Mathlib.Data.Finsupp.Lex._hyg.1508)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1521 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1523 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1521 x._@.Mathlib.Data.Finsupp.Lex._hyg.1523)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_le_right Finsupp.Lex.covariantClass_le_rightₓ'. -/
 instance Lex.covariantClass_le_right :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (Function.swap (· + ·)) (· ≤ ·) :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/62e8311c791f02c47451bf14aa2501048e7c2f33

@@ -43,7 +43,7 @@ protected def Lex (r : α → α → Prop) (s : N → N → Prop) (x y : α →
 
 /- warning: pi.lex_eq_finsupp_lex -> Pi.lex_eq_finsupp_lex is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] {r : α -> α -> Prop} {s : N -> N -> Prop} (a : Finsupp.{u1, u2} α N _inst_1) (b : Finsupp.{u1, u2} α N _inst_1), Eq.{1} Prop (Pi.Lex.{u1, u2} α (fun (_x : α) => N) r (fun (_x : α) => s) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.hasCoeToFun.{u1, u2} α N _inst_1) a) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.hasCoeToFun.{u1, u2} α N _inst_1) b)) (Finsupp.Lex.{u1, u2} α N _inst_1 r s a b)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] {r : α -> α -> Prop} {s : N -> N -> Prop} (a : Finsupp.{u1, u2} α N _inst_1) (b : Finsupp.{u1, u2} α N _inst_1), Eq.{1} Prop (Pi.Lex.{u1, u2} α (fun (_x : α) => N) r (fun (_x : α) => s) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) a) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) b)) (Finsupp.Lex.{u1, u2} α N _inst_1 r s a b)
 but is expected to have type
   forall {α : Type.{u2}} {N : Type.{u1}} [_inst_1 : Zero.{u1} N] {r : α -> α -> Prop} {s : N -> N -> Prop} (a : Finsupp.{u2, u1} α N _inst_1) (b : Finsupp.{u2, u1} α N _inst_1), Eq.{1} Prop (Pi.Lex.{u2, u1} α (fun {_x : α} => N) r (fun {_x : α} => s) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Finsupp.{u2, u1} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u2, u1} α N _inst_1) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Finsupp.{u2, u1} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u2, u1} α N _inst_1) b)) (Finsupp.Lex.{u2, u1} α N _inst_1 r s a b)
 Case conversion may be inaccurate. Consider using '#align pi.lex_eq_finsupp_lex Pi.lex_eq_finsupp_lexₓ'. -/
@@ -54,7 +54,7 @@ theorem Pi.lex_eq_finsupp_lex {r : α → α → Prop} {s : N → N → Prop} (a
 
 /- warning: finsupp.lex_def -> Finsupp.lex_def is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] {r : α -> α -> Prop} {s : N -> N -> Prop} {a : Finsupp.{u1, u2} α N _inst_1} {b : Finsupp.{u1, u2} α N _inst_1}, Iff (Finsupp.Lex.{u1, u2} α N _inst_1 r s a b) (Exists.{succ u1} α (fun (j : α) => And (forall (d : α), (r d j) -> (Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.hasCoeToFun.{u1, u2} α N _inst_1) a d) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.hasCoeToFun.{u1, u2} α N _inst_1) b d))) (s (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.hasCoeToFun.{u1, u2} α N _inst_1) a j) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.hasCoeToFun.{u1, u2} α N _inst_1) b j))))
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] {r : α -> α -> Prop} {s : N -> N -> Prop} {a : Finsupp.{u1, u2} α N _inst_1} {b : Finsupp.{u1, u2} α N _inst_1}, Iff (Finsupp.Lex.{u1, u2} α N _inst_1 r s a b) (Exists.{succ u1} α (fun (j : α) => And (forall (d : α), (r d j) -> (Eq.{succ u2} N (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) a d) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) b d))) (s (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) a j) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_1) (fun (_x : Finsupp.{u1, u2} α N _inst_1) => α -> N) (Finsupp.coeFun.{u1, u2} α N _inst_1) b j))))
 but is expected to have type
   forall {α : Type.{u2}} {N : Type.{u1}} [_inst_1 : Zero.{u1} N] {r : α -> α -> Prop} {s : N -> N -> Prop} {a : Finsupp.{u2, u1} α N _inst_1} {b : Finsupp.{u2, u1} α N _inst_1}, Iff (Finsupp.Lex.{u2, u1} α N _inst_1 r s a b) (Exists.{succ u2} α (fun (j : α) => And (forall (d : α), (r d j) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) d) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Finsupp.{u2, u1} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u2, u1} α N _inst_1) a d) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Finsupp.{u2, u1} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u2, u1} α N _inst_1) b d))) (s (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Finsupp.{u2, u1} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u2, u1} α N _inst_1) a j) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Finsupp.{u2, u1} α N _inst_1) α (fun (_x : α) => (fun (x._@.Mathlib.Data.Finsupp.Defs._hyg.779 : α) => N) _x) (Finsupp.funLike.{u2, u1} α N _inst_1) b j))))
 Case conversion may be inaccurate. Consider using '#align finsupp.lex_def Finsupp.lex_defₓ'. -/
@@ -161,7 +161,7 @@ variable [CovariantClass N N (· + ·) (· < ·)]
 
 /- warning: finsupp.lex.covariant_class_lt_left -> Finsupp.Lex.covariantClass_lt_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.hasAdd.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.927 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.929 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.927 x._@.Mathlib.Data.Finsupp.Lex._hyg.929) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.942 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.944 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.942 x._@.Mathlib.Data.Finsupp.Lex._hyg.944)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.978 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.980 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.978 x._@.Mathlib.Data.Finsupp.Lex._hyg.980) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.993 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.995 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.993 x._@.Mathlib.Data.Finsupp.Lex._hyg.995)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_lt_left Finsupp.Lex.covariantClass_lt_leftₓ'. -/
@@ -173,7 +173,7 @@ instance Lex.covariantClass_lt_left :
 
 /- warning: finsupp.lex.covariant_class_le_left -> Finsupp.Lex.covariantClass_le_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.hasAdd.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LE.le.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LE.le.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1082 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1084 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1082 x._@.Mathlib.Data.Finsupp.Lex._hyg.1084) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1097 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1099 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1097 x._@.Mathlib.Data.Finsupp.Lex._hyg.1099)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1133 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1135 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1133 x._@.Mathlib.Data.Finsupp.Lex._hyg.1135) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1148 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1150 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1148 x._@.Mathlib.Data.Finsupp.Lex._hyg.1150)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_le_left Finsupp.Lex.covariantClass_le_leftₓ'. -/
@@ -190,7 +190,7 @@ variable [CovariantClass N N (Function.swap (· + ·)) (· < ·)]
 
 /- warning: finsupp.lex.covariant_class_lt_right -> Finsupp.Lex.covariantClass_lt_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Function.swap.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (fun (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) => Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.hasAdd.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Function.swap.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (fun (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) => Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1241 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1243 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1241 x._@.Mathlib.Data.Finsupp.Lex._hyg.1243)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1256 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1258 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1256 x._@.Mathlib.Data.Finsupp.Lex._hyg.1258)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1295 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1297 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1295 x._@.Mathlib.Data.Finsupp.Lex._hyg.1297)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1310 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1312 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LT.lt.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1310 x._@.Mathlib.Data.Finsupp.Lex._hyg.1312)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_lt_right Finsupp.Lex.covariantClass_lt_rightₓ'. -/
@@ -202,7 +202,7 @@ instance Lex.covariantClass_lt_right :
 
 /- warning: finsupp.lex.covariant_class_le_right -> Finsupp.Lex.covariantClass_le_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Function.swap.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (fun (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) => Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.hasAdd.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) (LE.le.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toHasAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))))], CovariantClass.{max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Function.swap.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (fun (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (ᾰ : Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) => Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (instHAdd.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Lex.hasAdd.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) (LE.le.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3)))))))
 but is expected to have type
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] [_inst_4 : CovariantClass.{u2, u2} N N (Function.swap.{succ u2, succ u2, succ u2} N N (fun (ᾰ : N) (ᾰ : N) => N) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1414 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1416 : N) => HAdd.hAdd.{u2, u2, u2} N N N (instHAdd.{u2} N (AddZeroClass.toAdd.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1414 x._@.Mathlib.Data.Finsupp.Lex._hyg.1416)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1429 : N) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1431 : N) => LT.lt.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3)))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1429 x._@.Mathlib.Data.Finsupp.Lex._hyg.1431)], CovariantClass.{max u2 u1, max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Function.swap.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (ᾰ : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1468 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1470 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instHAdd.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (instAddLex.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2)) (Finsupp.add.{u1, u2} α N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1468 x._@.Mathlib.Data.Finsupp.Lex._hyg.1470)) (fun (x._@.Mathlib.Data.Finsupp.Lex._hyg.1483 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (x._@.Mathlib.Data.Finsupp.Lex._hyg.1485 : Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) => LE.le.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Preorder.toLE.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2))) (Finsupp.Lex.partialOrder.{u1, u2} α N (AddMonoid.toZero.{u2} N _inst_2) _inst_1 (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (DistribLattice.toLattice.{u2} N (instDistribLattice.{u2} N _inst_3))))))) x._@.Mathlib.Data.Finsupp.Lex._hyg.1483 x._@.Mathlib.Data.Finsupp.Lex._hyg.1485)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.covariant_class_le_right Finsupp.Lex.covariantClass_le_rightₓ'. -/

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

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

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

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

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

@@ -77,7 +77,7 @@ instance Lex.partialOrder [PartialOrder N] : PartialOrder (Lex (α →₀ N)) wh
   lt := (· < ·)
   le x y := ⇑(ofLex x) = ⇑(ofLex y) ∨ x < y
   __ := PartialOrder.lift (fun x : Lex (α →₀ N) ↦ toLex (⇑(ofLex x)))
-    (FunLike.coe_injective (F := Finsupp α N))
+    (DFunLike.coe_injective (F := Finsupp α N))
 #align finsupp.lex.partial_order Finsupp.Lex.partialOrder
 
 /-- The linear order on `Finsupp`s obtained by the lexicographic ordering. -/

Renames:

CanonicallyOrderedMonoid -> CanonicallyOrderedCommMonoid

CanonicallyOrderedAddMonoid -> CanonicallyOrderedAddCommMonoid

CanonicallyLinearOrderedMonoid -> CanonicallyLinearOrderedCommMonoid

CanonicallyLinearOrderedAddMonoid -> CanonicallyLinearOrderedAddCommMonoid

@@ -151,7 +151,7 @@ section OrderedAddMonoid
 
 variable [LinearOrder α]
 
-instance Lex.orderBot [CanonicallyOrderedAddMonoid N] : OrderBot (Lex (α →₀ N)) where
+instance Lex.orderBot [CanonicallyOrderedAddCommMonoid N] : OrderBot (Lex (α →₀ N)) where
   bot := 0
   bot_le _ := Finsupp.toLex_monotone bot_le
 

@@ -73,14 +73,18 @@ variable [LinearOrder α]
 
 /-- The partial order on `Finsupp`s obtained by the lexicographic ordering.
 See `Finsupp.Lex.linearOrder` for a proof that this partial order is in fact linear. -/
-instance Lex.partialOrder [PartialOrder N] : PartialOrder (Lex (α →₀ N)) :=
-  PartialOrder.lift (fun x ↦ toLex (⇑(ofLex x))) (FunLike.coe_injective (F := Finsupp α N))
+instance Lex.partialOrder [PartialOrder N] : PartialOrder (Lex (α →₀ N)) where
+  lt := (· < ·)
+  le x y := ⇑(ofLex x) = ⇑(ofLex y) ∨ x < y
+  __ := PartialOrder.lift (fun x : Lex (α →₀ N) ↦ toLex (⇑(ofLex x)))
+    (FunLike.coe_injective (F := Finsupp α N))
 #align finsupp.lex.partial_order Finsupp.Lex.partialOrder
 
 /-- The linear order on `Finsupp`s obtained by the lexicographic ordering. -/
-instance Lex.linearOrder [LinearOrder N] : LinearOrder (Lex (α →₀ N)) :=
-  { @Lex.partialOrder α N _ _ _,  -- Porting note: Added types to avoid typeclass inference problem.
-    LinearOrder.lift' (toLex ∘ toDFinsupp ∘ ofLex) finsuppEquivDFinsupp.injective with }
+instance Lex.linearOrder [LinearOrder N] : LinearOrder (Lex (α →₀ N)) where
+  lt := (· < ·)
+  le := (· ≤ ·)
+  __ := LinearOrder.lift' (toLex ∘ toDFinsupp ∘ ofLex) finsuppEquivDFinsupp.injective
 #align finsupp.lex.linear_order Finsupp.Lex.linearOrder
 
 variable [PartialOrder N]
@@ -162,12 +166,12 @@ noncomputable instance Lex.orderedAddCommGroup [OrderedAddCommGroup N] :
 
 noncomputable instance Lex.linearOrderedCancelAddCommMonoid [LinearOrderedCancelAddCommMonoid N] :
     LinearOrderedCancelAddCommMonoid (Lex (α →₀ N)) where
-  __ := (inferInstance : LinearOrder (Lex (α →₀ N)))
-  __ := (inferInstance: OrderedCancelAddCommMonoid (Lex (α →₀ N)))
+  __ : LinearOrder (Lex (α →₀ N)) := inferInstance
+  __ : OrderedCancelAddCommMonoid (Lex (α →₀ N)) := inferInstance
 
 noncomputable instance Lex.linearOrderedAddCommGroup [LinearOrderedAddCommGroup N] :
     LinearOrderedAddCommGroup (Lex (α →₀ N)) where
-  __ := (inferInstance : LinearOrder (Lex (α →₀ N)))
+  __ : LinearOrder (Lex (α →₀ N)) := inferInstance
   add_le_add_left _ _ := add_le_add_left
 
 end OrderedAddMonoid

4 files have major changes:

Algebra/CovariantAndContravariant.lean

• Add new theorem contravariant_le_iff_contravariant_lt_and_eq.
• Add covariantClass_le_of_lt generalizing and replacing Mul.to_covariantClass_left/right in Algebra/Order/Monoid/Defs.lean
• Replace CommSemigroup by IsSymmOp N N mu and replace CancelSemigroup by IsMulCancel, removing superfluous associativity assumption.
• new theorems covariant_lt_of_covariant_le_of_contravariant_eq and contravariant_le_of_contravariant_eq_and_lt that could replace eight instances when appropriate refactoring is in place.
• Golfs
• Fix changed names in other files.

Algebra/Order/Monoid/Lemmas.lean

• Generalize mul_eq_mul_iff_eq_and_eq and remove the less general Left/Right.mul_eq_mul_iff_eq_and_eq.
• Move mul_le_mul_iff_of_ge.
• Introduce the more general Left/Right versions of min_le_max_of_mul_le_mul.
• Move min_lt_max_of_mul_lt_mul here from Algebra/GroupPower/Order.lean.
• Replace CommSemigroup by IsSymmOp.

Algebra/Order/Monoid/Basic.lean

• Remove eq_and_eq_of_le_of_le_of_mul_le as it's just one direction of mul_le_mul_iff_of_ge but with more assumptions.

Algebra/Order/Ring/Lemmas.lean

• Generalize two versions of mul_eq_mul_iff_eq_and_eq_of_pos
• Golfs

Changes to Algebra/Group/UniqueProds.lean and Algebra/MonoidAlgebra/NoZeroDivisors.lean are in declarations that will be removed by #6723.

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

@@ -119,7 +119,7 @@ instance Lex.covariantClass_lt_left :
 
 instance Lex.covariantClass_le_left :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (· + ·) (· ≤ ·) :=
-  Add.to_covariantClass_left _
+  covariantClass_le_of_lt _ _ _
 #align finsupp.lex.covariant_class_le_left Finsupp.Lex.covariantClass_le_left
 
 end Left
@@ -136,7 +136,7 @@ instance Lex.covariantClass_lt_right :
 
 instance Lex.covariantClass_le_right :
     CovariantClass (Lex (α →₀ N)) (Lex (α →₀ N)) (Function.swap (· + ·)) (· ≤ ·) :=
-  Add.to_covariantClass_right _
+  covariantClass_le_of_lt _ _ _
 #align finsupp.lex.covariant_class_le_right Finsupp.Lex.covariantClass_le_right
 
 end Right

This PR just touches doc-strings. It fixes capitalization issues involving Counterexamples and adds a missing line-break for better display.

@@ -105,7 +105,7 @@ We assume `CovariantClass` with *strict* inequality `<` also when proving the on
 *weak* inequality `≤`.  This is actually necessary: addition on `Lex (α →₀ N)` may fail to be
 monotone, when it is "just" monotone on `N`.
 
-See `counterexamples.zero_divisors_in_add_monoid_algebras` for a counterexample. -/
+See `Counterexamples/ZeroDivisorsInAddMonoidAlgebras.lean` for a counterexample. -/
 
 
 section Left

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -143,4 +143,33 @@ end Right
 
 end Covariants
 
+section OrderedAddMonoid
+
+variable [LinearOrder α]
+
+instance Lex.orderBot [CanonicallyOrderedAddMonoid N] : OrderBot (Lex (α →₀ N)) where
+  bot := 0
+  bot_le _ := Finsupp.toLex_monotone bot_le
+
+noncomputable instance Lex.orderedAddCancelCommMonoid [OrderedCancelAddCommMonoid N] :
+    OrderedCancelAddCommMonoid (Lex (α →₀ N)) where
+  add_le_add_left _ _ h _ := add_le_add_left (α := Lex (α → N)) h _
+  le_of_add_le_add_left _ _ _ := le_of_add_le_add_left (α := Lex (α → N))
+
+noncomputable instance Lex.orderedAddCommGroup [OrderedAddCommGroup N] :
+    OrderedAddCommGroup (Lex (α →₀ N)) where
+  add_le_add_left _ _ := add_le_add_left
+
+noncomputable instance Lex.linearOrderedCancelAddCommMonoid [LinearOrderedCancelAddCommMonoid N] :
+    LinearOrderedCancelAddCommMonoid (Lex (α →₀ N)) where
+  __ := (inferInstance : LinearOrder (Lex (α →₀ N)))
+  __ := (inferInstance: OrderedCancelAddCommMonoid (Lex (α →₀ N)))
+
+noncomputable instance Lex.linearOrderedAddCommGroup [LinearOrderedAddCommGroup N] :
+    LinearOrderedAddCommGroup (Lex (α →₀ N)) where
+  __ := (inferInstance : LinearOrder (Lex (α →₀ N)))
+  add_le_add_left _ _ := add_le_add_left
+
+end OrderedAddMonoid
+
 end Finsupp

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

This has nice performance benefits.

@@ -16,7 +16,7 @@ This file defines the lexicographic order on `Finsupp`.
 -/
 
 
-variable {α N : Type _}
+variable {α N : Type*}
 
 namespace Finsupp
 

• depends on: #5966

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

@@ -2,16 +2,13 @@
 Copyright (c) 2022 Damiano Testa. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Damiano Testa
-
-! This file was ported from Lean 3 source module data.finsupp.lex
-! leanprover-community/mathlib commit dc6c365e751e34d100e80fe6e314c3c3e0fd2988
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Finsupp.Order
 import Mathlib.Data.DFinsupp.Lex
 import Mathlib.Data.Finsupp.ToDFinsupp
 
+#align_import data.finsupp.lex from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
+
 /-!
 # Lexicographic order on finitely supported functions
 

See #4354

@@ -9,8 +9,8 @@ Authors: Damiano Testa
 ! if you have ported upstream changes.
 -/
 import Mathlib.Data.Finsupp.Order
-import Mathlib.Data.Dfinsupp.Lex
-import Mathlib.Data.Finsupp.ToDfinsupp
+import Mathlib.Data.DFinsupp.Lex
+import Mathlib.Data.Finsupp.ToDFinsupp
 
 /-!
 # Lexicographic order on finitely supported functions
@@ -48,7 +48,7 @@ theorem lex_def {r : α → α → Prop} {s : N → N → Prop} {a b : α →₀
 #align finsupp.lex_def Finsupp.lex_def
 
 theorem lex_eq_invImage_dfinsupp_lex (r : α → α → Prop) (s : N → N → Prop) :
-    Finsupp.Lex r s = InvImage (Dfinsupp.Lex r fun _ ↦ s) toDfinsupp :=
+    Finsupp.Lex r s = InvImage (DFinsupp.Lex r fun _ ↦ s) toDFinsupp :=
   rfl
 #align finsupp.lex_eq_inv_image_dfinsupp_lex Finsupp.lex_eq_invImage_dfinsupp_lex
 
@@ -57,12 +57,12 @@ instance [LT α] [LT N] : LT (Lex (α →₀ N)) :=
 
 theorem lex_lt_of_lt_of_preorder [Preorder N] (r) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y) :
     ∃ i, (∀ j, r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i :=
-  Dfinsupp.lex_lt_of_lt_of_preorder r (id hlt : x.toDfinsupp < y.toDfinsupp)
+  DFinsupp.lex_lt_of_lt_of_preorder r (id hlt : x.toDFinsupp < y.toDFinsupp)
 #align finsupp.lex_lt_of_lt_of_preorder Finsupp.lex_lt_of_lt_of_preorder
 
 theorem lex_lt_of_lt [PartialOrder N] (r) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y) :
     Pi.Lex r (· < ·) x y :=
-  Dfinsupp.lex_lt_of_lt r (id hlt : x.toDfinsupp < y.toDfinsupp)
+  DFinsupp.lex_lt_of_lt r (id hlt : x.toDFinsupp < y.toDFinsupp)
 #align finsupp.lex_lt_of_lt Finsupp.lex_lt_of_lt
 
 instance Lex.isStrictOrder [LinearOrder α] [PartialOrder N] :
@@ -83,13 +83,13 @@ instance Lex.partialOrder [PartialOrder N] : PartialOrder (Lex (α →₀ N)) :=
 /-- The linear order on `Finsupp`s obtained by the lexicographic ordering. -/
 instance Lex.linearOrder [LinearOrder N] : LinearOrder (Lex (α →₀ N)) :=
   { @Lex.partialOrder α N _ _ _,  -- Porting note: Added types to avoid typeclass inference problem.
-    LinearOrder.lift' (toLex ∘ toDfinsupp ∘ ofLex) finsuppEquivDfinsupp.injective with }
+    LinearOrder.lift' (toLex ∘ toDFinsupp ∘ ofLex) finsuppEquivDFinsupp.injective with }
 #align finsupp.lex.linear_order Finsupp.Lex.linearOrder
 
 variable [PartialOrder N]
 
 theorem toLex_monotone : Monotone (@toLex (α →₀ N)) :=
-  fun a b h ↦ Dfinsupp.toLex_monotone (id h : ∀ i, ofLex (toDfinsupp a) i ≤ ofLex (toDfinsupp b) i)
+  fun a b h ↦ DFinsupp.toLex_monotone (id h : ∀ i, ofLex (toDFinsupp a) i ≤ ofLex (toDFinsupp b) i)
 #align finsupp.to_lex_monotone Finsupp.toLex_monotone
 
 theorem lt_of_forall_lt_of_lt (a b : Lex (α →₀ N)) (i : α) :

Other changes:

• modify Data/Dfinsupp/Lex to use explicit (i : ι);
• fix 2 typos&align in Logic.Basic.

@@ -48,7 +48,7 @@ theorem lex_def {r : α → α → Prop} {s : N → N → Prop} {a b : α →₀
 #align finsupp.lex_def Finsupp.lex_def
 
 theorem lex_eq_invImage_dfinsupp_lex (r : α → α → Prop) (s : N → N → Prop) :
-    Finsupp.Lex r s = InvImage (Dfinsupp.Lex r s) toDfinsupp :=
+    Finsupp.Lex r s = InvImage (Dfinsupp.Lex r fun _ ↦ s) toDfinsupp :=
   rfl
 #align finsupp.lex_eq_inv_image_dfinsupp_lex Finsupp.lex_eq_invImage_dfinsupp_lex