order.grade ⟷ Mathlib.Order.Grade

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

@@ -73,7 +73,7 @@ which preserves order covering (`covby`). -/
 class GradeOrder (𝕆 α : Type _) [Preorder 𝕆] [Preorder α] where
   grade : α → 𝕆
   grade_strictMono : StrictMono grade
-  covby_grade ⦃a b : α⦄ : a ⋖ b → grade a ⋖ grade b
+  covBy_grade ⦃a b : α⦄ : a ⋖ b → grade a ⋖ grade b
 #align grade_order GradeOrder
 -/
 
@@ -121,10 +121,10 @@ def grade : α → 𝕆 :=
 #align grade grade
 -/
 
-#print Covby.grade /-
-protected theorem Covby.grade (h : a ⋖ b) : grade 𝕆 a ⋖ grade 𝕆 b :=
-  GradeOrder.covby_grade h
-#align covby.grade Covby.grade
+#print CovBy.grade /-
+protected theorem CovBy.grade (h : a ⋖ b) : grade 𝕆 a ⋖ grade 𝕆 b :=
+  GradeOrder.covBy_grade h
+#align covby.grade CovBy.grade
 -/
 
 variable {𝕆}
@@ -135,11 +135,11 @@ theorem grade_strictMono : StrictMono (grade 𝕆 : α → 𝕆) :=
 #align grade_strict_mono grade_strictMono
 -/
 
-#print covby_iff_lt_covby_grade /-
-theorem covby_iff_lt_covby_grade : a ⋖ b ↔ a < b ∧ grade 𝕆 a ⋖ grade 𝕆 b :=
+#print covBy_iff_lt_covBy_grade /-
+theorem covBy_iff_lt_covBy_grade : a ⋖ b ↔ a < b ∧ grade 𝕆 a ⋖ grade 𝕆 b :=
   ⟨fun h => ⟨h.1, h.grade _⟩,
     And.imp_right fun h c ha hb => h.2 (grade_strictMono ha) <| grade_strictMono hb⟩
-#align covby_iff_lt_covby_grade covby_iff_lt_covby_grade
+#align covby_iff_lt_covby_grade covBy_iff_lt_covBy_grade
 -/
 
 end GradeOrder
@@ -233,10 +233,10 @@ theorem grade_ne_grade_iff : grade 𝕆 a ≠ grade 𝕆 b ↔ a ≠ b :=
 #align grade_ne_grade_iff grade_ne_grade_iff
 -/
 
-#print grade_covby_grade_iff /-
-theorem grade_covby_grade_iff : grade 𝕆 a ⋖ grade 𝕆 b ↔ a ⋖ b :=
-  (covby_iff_lt_covby_grade.trans <| and_iff_right_of_imp fun h => grade_lt_grade_iff.1 h.1).symm
-#align grade_covby_grade_iff grade_covby_grade_iff
+#print grade_covBy_grade_iff /-
+theorem grade_covBy_grade_iff : grade 𝕆 a ⋖ grade 𝕆 b ↔ a ⋖ b :=
+  (covBy_iff_lt_covBy_grade.trans <| and_iff_right_of_imp fun h => grade_lt_grade_iff.1 h.1).symm
+#align grade_covby_grade_iff grade_covBy_grade_iff
 -/
 
 end LinearOrder
@@ -277,7 +277,7 @@ instance Preorder.toGradeBoundedOrder : GradeBoundedOrder α α
   isMin_grade _ := id
   isMax_grade _ := id
   grade_strictMono := strictMono_id
-  covby_grade a b := id
+  covBy_grade a b := id
 #align preorder.to_grade_bounded_order Preorder.toGradeBoundedOrder
 -/
 
@@ -295,7 +295,7 @@ instance [GradeOrder 𝕆 α] : GradeOrder 𝕆ᵒᵈ αᵒᵈ
     where
   grade := toDual ∘ grade 𝕆 ∘ ofDual
   grade_strictMono := grade_strictMono.dual
-  covby_grade a b h := (h.ofDual.grade _).toDual
+  covBy_grade a b h := (h.ofDual.grade _).toDual
 
 instance [GradeMaxOrder 𝕆 α] : GradeMinOrder 𝕆ᵒᵈ αᵒᵈ :=
   { OrderDual.gradeOrder with isMin_grade := fun _ => IsMax.grade _ }
@@ -332,7 +332,7 @@ def GradeOrder.liftLeft [GradeOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono
     where
   grade := f ∘ grade 𝕆
   grade_strictMono := hf.comp grade_strictMono
-  covby_grade a b h := hcovby _ _ <| h.grade _
+  covBy_grade a b h := hcovby _ _ <| h.grade _
 #align grade_order.lift_left GradeOrder.liftLeft
 -/
 
@@ -376,7 +376,7 @@ def GradeOrder.liftRight [GradeOrder 𝕆 β] (f : α → β) (hf : StrictMono f
     where
   grade := grade 𝕆 ∘ f
   grade_strictMono := grade_strictMono.comp hf
-  covby_grade a b h := (hcovby _ _ h).grade _
+  covBy_grade a b h := (hcovby _ _ h).grade _
 #align grade_order.lift_right GradeOrder.liftRight
 -/
 
@@ -420,7 +420,7 @@ def GradeBoundedOrder.liftRight [GradeBoundedOrder 𝕆 β] (f : α → β) (hf
 inferrable. -/
 @[reducible]
 def GradeOrder.finToNat (n : ℕ) [GradeOrder (Fin n) α] : GradeOrder ℕ α :=
-  GradeOrder.liftLeft (_ : Fin n → ℕ) Fin.val_strictMono fun _ _ => Covby.coe_fin
+  GradeOrder.liftLeft (_ : Fin n → ℕ) Fin.val_strictMono fun _ _ => CovBy.coe_fin
 #align grade_order.fin_to_nat GradeOrder.finToNat
 -/
 
@@ -430,7 +430,7 @@ def GradeOrder.finToNat (n : ℕ) [GradeOrder (Fin n) α] : GradeOrder ℕ α :=
 inferrable. -/
 @[reducible]
 def GradeMinOrder.finToNat (n : ℕ) [GradeMinOrder (Fin n) α] : GradeMinOrder ℕ α :=
-  GradeMinOrder.liftLeft (_ : Fin n → ℕ) Fin.val_strictMono (fun _ _ => Covby.coe_fin) fun a h =>
+  GradeMinOrder.liftLeft (_ : Fin n → ℕ) Fin.val_strictMono (fun _ _ => CovBy.coe_fin) fun a h =>
     by
     cases n
     · exact ((@Fin.elim0 fun _ => False) <| grade (Fin 0) a).elim
@@ -441,7 +441,7 @@ def GradeMinOrder.finToNat (n : ℕ) [GradeMinOrder (Fin n) α] : GradeMinOrder
 
 #print GradeOrder.natToInt /-
 instance GradeOrder.natToInt [GradeOrder ℕ α] : GradeOrder ℤ α :=
-  GradeOrder.liftLeft _ Int.coe_nat_strictMono fun _ _ => Covby.cast_int
+  GradeOrder.liftLeft _ Int.coe_nat_strictMono fun _ _ => CovBy.cast_int
 #align grade_order.nat_to_int GradeOrder.natToInt
 -/
 

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

@@ -3,8 +3,8 @@ Copyright (c) 2022 Yaël Dillies, Violeta Hernández Palacios. All rights reserv
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies, Violeta Hernández Palacios, Grayson Burton, Vladimir Ivanov
 -/
-import Mathbin.Data.Finset.Basic
-import Mathbin.Data.Int.SuccPred
+import Data.Finset.Basic
+import Data.Int.SuccPred
 
 #align_import order.grade from "leanprover-community/mathlib"@"cc70d9141824ea8982d1562ce009952f2c3ece30"
 

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

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Yaël Dillies, Violeta Hernández Palacios. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies, Violeta Hernández Palacios, Grayson Burton, Vladimir Ivanov
-
-! This file was ported from Lean 3 source module order.grade
-! leanprover-community/mathlib commit cc70d9141824ea8982d1562ce009952f2c3ece30
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Finset.Basic
 import Mathbin.Data.Int.SuccPred
 
+#align_import order.grade from "leanprover-community/mathlib"@"cc70d9141824ea8982d1562ce009952f2c3ece30"
+
 /-!
 # Graded orders
 

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

@@ -116,26 +116,34 @@ section GradeOrder
 
 variable (𝕆) [GradeOrder 𝕆 α] {a b : α}
 
+#print grade /-
 /-- The grade of an element in a graded order. Morally, this is the number of elements you need to
 go down by to get to `⊥`. -/
 def grade : α → 𝕆 :=
   GradeOrder.grade
 #align grade grade
+-/
 
+#print Covby.grade /-
 protected theorem Covby.grade (h : a ⋖ b) : grade 𝕆 a ⋖ grade 𝕆 b :=
   GradeOrder.covby_grade h
 #align covby.grade Covby.grade
+-/
 
 variable {𝕆}
 
+#print grade_strictMono /-
 theorem grade_strictMono : StrictMono (grade 𝕆 : α → 𝕆) :=
   GradeOrder.grade_strictMono
 #align grade_strict_mono grade_strictMono
+-/
 
+#print covby_iff_lt_covby_grade /-
 theorem covby_iff_lt_covby_grade : a ⋖ b ↔ a < b ∧ grade 𝕆 a ⋖ grade 𝕆 b :=
   ⟨fun h => ⟨h.1, h.grade _⟩,
     And.imp_right fun h c ha hb => h.2 (grade_strictMono ha) <| grade_strictMono hb⟩
 #align covby_iff_lt_covby_grade covby_iff_lt_covby_grade
+-/
 
 end GradeOrder
 
@@ -143,16 +151,20 @@ section GradeMinOrder
 
 variable (𝕆) [GradeMinOrder 𝕆 α] {a : α}
 
+#print IsMin.grade /-
 protected theorem IsMin.grade (h : IsMin a) : IsMin (grade 𝕆 a) :=
   GradeMinOrder.isMin_grade h
 #align is_min.grade IsMin.grade
+-/
 
 variable {𝕆}
 
+#print isMin_grade_iff /-
 @[simp]
 theorem isMin_grade_iff : IsMin (grade 𝕆 a) ↔ IsMin a :=
   ⟨grade_strictMono.isMin_of_apply, IsMin.grade _⟩
 #align is_min_grade_iff isMin_grade_iff
+-/
 
 end GradeMinOrder
 
@@ -160,57 +172,75 @@ section GradeMaxOrder
 
 variable (𝕆) [GradeMaxOrder 𝕆 α] {a : α}
 
+#print IsMax.grade /-
 protected theorem IsMax.grade (h : IsMax a) : IsMax (grade 𝕆 a) :=
   GradeMaxOrder.isMax_grade h
 #align is_max.grade IsMax.grade
+-/
 
 variable {𝕆}
 
+#print isMax_grade_iff /-
 @[simp]
 theorem isMax_grade_iff : IsMax (grade 𝕆 a) ↔ IsMax a :=
   ⟨grade_strictMono.isMax_of_apply, IsMax.grade _⟩
 #align is_max_grade_iff isMax_grade_iff
+-/
 
 end GradeMaxOrder
 
 end Preorder
 
+#print grade_mono /-
 -- graded order
 theorem grade_mono [PartialOrder α] [GradeOrder 𝕆 α] : Monotone (grade 𝕆 : α → 𝕆) :=
   grade_strictMono.Monotone
 #align grade_mono grade_mono
+-/
 
 section LinearOrder
 
 -- graded order
 variable [LinearOrder α] [GradeOrder 𝕆 α] {a b : α}
 
+#print grade_injective /-
 theorem grade_injective : Function.Injective (grade 𝕆 : α → 𝕆) :=
   grade_strictMono.Injective
 #align grade_injective grade_injective
+-/
 
+#print grade_le_grade_iff /-
 @[simp]
 theorem grade_le_grade_iff : grade 𝕆 a ≤ grade 𝕆 b ↔ a ≤ b :=
   grade_strictMono.le_iff_le
 #align grade_le_grade_iff grade_le_grade_iff
+-/
 
+#print grade_lt_grade_iff /-
 @[simp]
 theorem grade_lt_grade_iff : grade 𝕆 a < grade 𝕆 b ↔ a < b :=
   grade_strictMono.lt_iff_lt
 #align grade_lt_grade_iff grade_lt_grade_iff
+-/
 
+#print grade_eq_grade_iff /-
 @[simp]
 theorem grade_eq_grade_iff : grade 𝕆 a = grade 𝕆 b ↔ a = b :=
   grade_injective.eq_iff
 #align grade_eq_grade_iff grade_eq_grade_iff
+-/
 
+#print grade_ne_grade_iff /-
 theorem grade_ne_grade_iff : grade 𝕆 a ≠ grade 𝕆 b ↔ a ≠ b :=
   grade_injective.ne_iff
 #align grade_ne_grade_iff grade_ne_grade_iff
+-/
 
+#print grade_covby_grade_iff /-
 theorem grade_covby_grade_iff : grade 𝕆 a ⋖ grade 𝕆 b ↔ a ⋖ b :=
   (covby_iff_lt_covby_grade.trans <| and_iff_right_of_imp fun h => grade_lt_grade_iff.1 h.1).symm
 #align grade_covby_grade_iff grade_covby_grade_iff
+-/
 
 end LinearOrder
 
@@ -222,15 +252,19 @@ section PartialOrder
 
 variable [PartialOrder 𝕆] [Preorder α]
 
+#print grade_bot /-
 @[simp]
 theorem grade_bot [OrderBot 𝕆] [OrderBot α] [GradeMinOrder 𝕆 α] : grade 𝕆 (⊥ : α) = ⊥ :=
   (isMin_bot.grade _).eq_bot
 #align grade_bot grade_bot
+-/
 
+#print grade_top /-
 @[simp]
 theorem grade_top [OrderTop 𝕆] [OrderTop α] [GradeMaxOrder 𝕆 α] : grade 𝕆 (⊤ : α) = ⊤ :=
   (isMax_top.grade _).eq_top
 #align grade_top grade_top
+-/
 
 end PartialOrder
 
@@ -275,15 +309,19 @@ instance [GradeMinOrder 𝕆 α] : GradeMaxOrder 𝕆ᵒᵈ αᵒᵈ :=
 instance [GradeBoundedOrder 𝕆 α] : GradeBoundedOrder 𝕆ᵒᵈ αᵒᵈ :=
   { OrderDual.gradeMinOrder, OrderDual.gradeMaxOrder with }
 
+#print grade_toDual /-
 @[simp]
 theorem grade_toDual [GradeOrder 𝕆 α] (a : α) : grade 𝕆ᵒᵈ (toDual a) = toDual (grade 𝕆 a) :=
   rfl
 #align grade_to_dual grade_toDual
+-/
 
+#print grade_ofDual /-
 @[simp]
 theorem grade_ofDual [GradeOrder 𝕆 α] (a : αᵒᵈ) : grade 𝕆 (ofDual a) = ofDual (grade 𝕆ᵒᵈ a) :=
   rfl
 #align grade_of_dual grade_ofDual
+-/
 
 /-! #### Lifting a graded order -/
 
@@ -379,6 +417,7 @@ def GradeBoundedOrder.liftRight [GradeBoundedOrder 𝕆 β] (f : α → β) (hf
 /-! #### `fin n`-graded to `ℕ`-graded to `ℤ`-graded -/
 
 
+#print GradeOrder.finToNat /-
 -- See note [reducible non-instances]
 /-- A `fin n`-graded order is also `ℕ`-graded. We do not mark this an instance because `n` is not
 inferrable. -/
@@ -386,7 +425,9 @@ inferrable. -/
 def GradeOrder.finToNat (n : ℕ) [GradeOrder (Fin n) α] : GradeOrder ℕ α :=
   GradeOrder.liftLeft (_ : Fin n → ℕ) Fin.val_strictMono fun _ _ => Covby.coe_fin
 #align grade_order.fin_to_nat GradeOrder.finToNat
+-/
 
+#print GradeMinOrder.finToNat /-
 -- See note [reducible non-instances]
 /-- A `fin n`-graded order is also `ℕ`-graded. We do not mark this an instance because `n` is not
 inferrable. -/
@@ -399,6 +440,7 @@ def GradeMinOrder.finToNat (n : ℕ) [GradeMinOrder (Fin n) α] : GradeMinOrder
     rw [h.eq_bot, Fin.bot_eq_zero]
     exact isMin_bot
 #align grade_min_order.fin_to_nat GradeMinOrder.finToNat
+-/
 
 #print GradeOrder.natToInt /-
 instance GradeOrder.natToInt [GradeOrder ℕ α] : GradeOrder ℤ α :=

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

@@ -98,7 +98,7 @@ class GradeMaxOrder (𝕆 α : Type _) [Preorder 𝕆] [Preorder α] extends Gra
 /-- A `𝕆`-graded order where minimal elements have minimal grades and maximal elements have maximal
 grades. -/
 class GradeBoundedOrder (𝕆 α : Type _) [Preorder 𝕆] [Preorder α] extends GradeMinOrder 𝕆 α,
-  GradeMaxOrder 𝕆 α
+    GradeMaxOrder 𝕆 α
 #align grade_bounded_order GradeBoundedOrder
 -/
 

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

@@ -288,6 +288,7 @@ theorem grade_ofDual [GradeOrder 𝕆 α] (a : αᵒᵈ) : grade 𝕆 (ofDual a)
 /-! #### Lifting a graded order -/
 
 
+#print GradeOrder.liftLeft /-
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -298,7 +299,9 @@ def GradeOrder.liftLeft [GradeOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono
   grade_strictMono := hf.comp grade_strictMono
   covby_grade a b h := hcovby _ _ <| h.grade _
 #align grade_order.lift_left GradeOrder.liftLeft
+-/
 
+#print GradeMinOrder.liftLeft /-
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -306,7 +309,9 @@ def GradeMinOrder.liftLeft [GradeMinOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : Stri
     (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a)) : GradeMinOrder ℙ α :=
   { GradeOrder.liftLeft f hf hcovby with isMin_grade := fun a ha => hmin _ <| ha.grade _ }
 #align grade_min_order.lift_left GradeMinOrder.liftLeft
+-/
 
+#print GradeMaxOrder.liftLeft /-
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -314,7 +319,9 @@ def GradeMaxOrder.liftLeft [GradeMaxOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : Stri
     (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeMaxOrder ℙ α :=
   { GradeOrder.liftLeft f hf hcovby with isMax_grade := fun a ha => hmax _ <| ha.grade _ }
 #align grade_max_order.lift_left GradeMaxOrder.liftLeft
+-/
 
+#print GradeBoundedOrder.liftLeft /-
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -323,7 +330,9 @@ def GradeBoundedOrder.liftLeft [GradeBoundedOrder 𝕆 α] (f : 𝕆 → ℙ) (h
     (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeBoundedOrder ℙ α :=
   { GradeMinOrder.liftLeft f hf hcovby hmin, GradeMaxOrder.liftLeft f hf hcovby hmax with }
 #align grade_bounded_order.lift_left GradeBoundedOrder.liftLeft
+-/
 
+#print GradeOrder.liftRight /-
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -334,7 +343,9 @@ def GradeOrder.liftRight [GradeOrder 𝕆 β] (f : α → β) (hf : StrictMono f
   grade_strictMono := grade_strictMono.comp hf
   covby_grade a b h := (hcovby _ _ h).grade _
 #align grade_order.lift_right GradeOrder.liftRight
+-/
 
+#print GradeMinOrder.liftRight /-
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -342,7 +353,9 @@ def GradeMinOrder.liftRight [GradeMinOrder 𝕆 β] (f : α → β) (hf : Strict
     (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a)) : GradeMinOrder 𝕆 α :=
   { GradeOrder.liftRight f hf hcovby with isMin_grade := fun a ha => (hmin _ ha).grade _ }
 #align grade_min_order.lift_right GradeMinOrder.liftRight
+-/
 
+#print GradeMaxOrder.liftRight /-
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -350,7 +363,9 @@ def GradeMaxOrder.liftRight [GradeMaxOrder 𝕆 β] (f : α → β) (hf : Strict
     (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeMaxOrder 𝕆 α :=
   { GradeOrder.liftRight f hf hcovby with isMax_grade := fun a ha => (hmax _ ha).grade _ }
 #align grade_max_order.lift_right GradeMaxOrder.liftRight
+-/
 
+#print GradeBoundedOrder.liftRight /-
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -359,6 +374,7 @@ def GradeBoundedOrder.liftRight [GradeBoundedOrder 𝕆 β] (f : α → β) (hf
     (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeBoundedOrder 𝕆 α :=
   { GradeMinOrder.liftRight f hf hcovby hmin, GradeMaxOrder.liftRight f hf hcovby hmax with }
 #align grade_bounded_order.lift_right GradeBoundedOrder.liftRight
+-/
 
 /-! #### `fin n`-graded to `ℕ`-graded to `ℤ`-graded -/
 

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

@@ -116,46 +116,22 @@ section GradeOrder
 
 variable (𝕆) [GradeOrder 𝕆 α] {a b : α}
 
-/- warning: grade -> grade is a dubious translation:
-lean 3 declaration is
-  forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2], α -> 𝕆
-but is expected to have type
-  forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} 𝕆] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_2 _inst_1], α -> 𝕆
-Case conversion may be inaccurate. Consider using '#align grade gradeₓ'. -/
 /-- The grade of an element in a graded order. Morally, this is the number of elements you need to
 go down by to get to `⊥`. -/
 def grade : α → 𝕆 :=
   GradeOrder.grade
 #align grade grade
 
-/- warning: covby.grade -> Covby.grade is a dubious translation:
-lean 3 declaration is
-  forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α} {b : α}, (Covby.{u2} α (Preorder.toHasLt.{u2} α _inst_2) a b) -> (Covby.{u1} 𝕆 (Preorder.toHasLt.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 b))
-but is expected to have type
-  forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} 𝕆] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_2 _inst_1] {a : α} {b : α}, (Covby.{u2} α (Preorder.toLT.{u2} α _inst_1) a b) -> (Covby.{u1} 𝕆 (Preorder.toLT.{u1} 𝕆 _inst_2) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 b))
-Case conversion may be inaccurate. Consider using '#align covby.grade Covby.gradeₓ'. -/
 protected theorem Covby.grade (h : a ⋖ b) : grade 𝕆 a ⋖ grade 𝕆 b :=
   GradeOrder.covby_grade h
 #align covby.grade Covby.grade
 
 variable {𝕆}
 
-/- warning: grade_strict_mono -> grade_strictMono is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2], StrictMono.{u2, u1} α 𝕆 _inst_2 _inst_1 (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3)
-but is expected to have type
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} 𝕆] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_2 _inst_1], StrictMono.{u2, u1} α 𝕆 _inst_1 _inst_2 (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3)
-Case conversion may be inaccurate. Consider using '#align grade_strict_mono grade_strictMonoₓ'. -/
 theorem grade_strictMono : StrictMono (grade 𝕆 : α → 𝕆) :=
   GradeOrder.grade_strictMono
 #align grade_strict_mono grade_strictMono
 
-/- warning: covby_iff_lt_covby_grade -> covby_iff_lt_covby_grade is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α} {b : α}, Iff (Covby.{u2} α (Preorder.toHasLt.{u2} α _inst_2) a b) (And (LT.lt.{u2} α (Preorder.toHasLt.{u2} α _inst_2) a b) (Covby.{u1} 𝕆 (Preorder.toHasLt.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 b)))
-but is expected to have type
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} 𝕆] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_2 _inst_1] {a : α} {b : α}, Iff (Covby.{u2} α (Preorder.toLT.{u2} α _inst_1) a b) (And (LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_1) a b) (Covby.{u1} 𝕆 (Preorder.toLT.{u1} 𝕆 _inst_2) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 b)))
-Case conversion may be inaccurate. Consider using '#align covby_iff_lt_covby_grade covby_iff_lt_covby_gradeₓ'. -/
 theorem covby_iff_lt_covby_grade : a ⋖ b ↔ a < b ∧ grade 𝕆 a ⋖ grade 𝕆 b :=
   ⟨fun h => ⟨h.1, h.grade _⟩,
     And.imp_right fun h c ha hb => h.2 (grade_strictMono ha) <| grade_strictMono hb⟩
@@ -167,24 +143,12 @@ section GradeMinOrder
 
 variable (𝕆) [GradeMinOrder 𝕆 α] {a : α}
 
-/- warning: is_min.grade -> IsMin.grade is a dubious translation:
-lean 3 declaration is
-  forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeMinOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α}, (IsMin.{u2} α (Preorder.toHasLe.{u2} α _inst_2) a) -> (IsMin.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 (GradeMinOrder.toGradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3) a))
-but is expected to have type
-  forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} 𝕆] [_inst_3 : GradeMinOrder.{u1, u2} 𝕆 α _inst_2 _inst_1] {a : α}, (IsMin.{u2} α (Preorder.toLE.{u2} α _inst_1) a) -> (IsMin.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_2) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 (GradeMinOrder.toGradeOrder.{u1, u2} 𝕆 α _inst_2 _inst_1 _inst_3) a))
-Case conversion may be inaccurate. Consider using '#align is_min.grade IsMin.gradeₓ'. -/
 protected theorem IsMin.grade (h : IsMin a) : IsMin (grade 𝕆 a) :=
   GradeMinOrder.isMin_grade h
 #align is_min.grade IsMin.grade
 
 variable {𝕆}
 
-/- warning: is_min_grade_iff -> isMin_grade_iff is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeMinOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α}, Iff (IsMin.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 (GradeMinOrder.toGradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3) a)) (IsMin.{u2} α (Preorder.toHasLe.{u2} α _inst_2) a)
-but is expected to have type
-  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} 𝕆] [_inst_3 : GradeMinOrder.{u2, u1} 𝕆 α _inst_2 _inst_1] {a : α}, Iff (IsMin.{u2} 𝕆 (Preorder.toLE.{u2} 𝕆 _inst_2) (grade.{u2, u1} 𝕆 α _inst_1 _inst_2 (GradeMinOrder.toGradeOrder.{u2, u1} 𝕆 α _inst_2 _inst_1 _inst_3) a)) (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align is_min_grade_iff isMin_grade_iffₓ'. -/
 @[simp]
 theorem isMin_grade_iff : IsMin (grade 𝕆 a) ↔ IsMin a :=
   ⟨grade_strictMono.isMin_of_apply, IsMin.grade _⟩
@@ -196,24 +160,12 @@ section GradeMaxOrder
 
 variable (𝕆) [GradeMaxOrder 𝕆 α] {a : α}
 
-/- warning: is_max.grade -> IsMax.grade is a dubious translation:
-lean 3 declaration is
-  forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeMaxOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α}, (IsMax.{u2} α (Preorder.toHasLe.{u2} α _inst_2) a) -> (IsMax.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 (GradeMaxOrder.toGradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3) a))
-but is expected to have type
-  forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} 𝕆] [_inst_3 : GradeMaxOrder.{u1, u2} 𝕆 α _inst_2 _inst_1] {a : α}, (IsMax.{u2} α (Preorder.toLE.{u2} α _inst_1) a) -> (IsMax.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_2) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 (GradeMaxOrder.toGradeOrder.{u1, u2} 𝕆 α _inst_2 _inst_1 _inst_3) a))
-Case conversion may be inaccurate. Consider using '#align is_max.grade IsMax.gradeₓ'. -/
 protected theorem IsMax.grade (h : IsMax a) : IsMax (grade 𝕆 a) :=
   GradeMaxOrder.isMax_grade h
 #align is_max.grade IsMax.grade
 
 variable {𝕆}
 
-/- warning: is_max_grade_iff -> isMax_grade_iff is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeMaxOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α}, Iff (IsMax.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 (GradeMaxOrder.toGradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3) a)) (IsMax.{u2} α (Preorder.toHasLe.{u2} α _inst_2) a)
-but is expected to have type
-  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} 𝕆] [_inst_3 : GradeMaxOrder.{u2, u1} 𝕆 α _inst_2 _inst_1] {a : α}, Iff (IsMax.{u2} 𝕆 (Preorder.toLE.{u2} 𝕆 _inst_2) (grade.{u2, u1} 𝕆 α _inst_1 _inst_2 (GradeMaxOrder.toGradeOrder.{u2, u1} 𝕆 α _inst_2 _inst_1 _inst_3) a)) (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align is_max_grade_iff isMax_grade_iffₓ'. -/
 @[simp]
 theorem isMax_grade_iff : IsMax (grade 𝕆 a) ↔ IsMax a :=
   ⟨grade_strictMono.isMax_of_apply, IsMax.grade _⟩
@@ -223,12 +175,6 @@ end GradeMaxOrder
 
 end Preorder
 
-/- warning: grade_mono -> grade_mono is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : PartialOrder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α _inst_2)], Monotone.{u2, u1} α 𝕆 (PartialOrder.toPreorder.{u2} α _inst_2) _inst_1 (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α _inst_2) _inst_3)
-but is expected to have type
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} 𝕆] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_2 (PartialOrder.toPreorder.{u2} α _inst_1)], Monotone.{u2, u1} α 𝕆 (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 (grade.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 _inst_3)
-Case conversion may be inaccurate. Consider using '#align grade_mono grade_monoₓ'. -/
 -- graded order
 theorem grade_mono [PartialOrder α] [GradeOrder 𝕆 α] : Monotone (grade 𝕆 : α → 𝕆) :=
   grade_strictMono.Monotone
@@ -239,65 +185,29 @@ section LinearOrder
 -- graded order
 variable [LinearOrder α] [GradeOrder 𝕆 α] {a b : α}
 
-/- warning: grade_injective -> grade_injective is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))], Function.Injective.{succ u2, succ u1} α 𝕆 (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3)
-but is expected to have type
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] [_inst_2 : Preorder.{u1} 𝕆] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_2 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))], Function.Injective.{succ u2, succ u1} α 𝕆 (grade.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) _inst_2 _inst_3)
-Case conversion may be inaccurate. Consider using '#align grade_injective grade_injectiveₓ'. -/
 theorem grade_injective : Function.Injective (grade 𝕆 : α → 𝕆) :=
   grade_strictMono.Injective
 #align grade_injective grade_injective
 
-/- warning: grade_le_grade_iff -> grade_le_grade_iff is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))] {a : α} {b : α}, Iff (LE.le.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 b)) (LE.le.{u2} α (Preorder.toHasLe.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))) a b)
-but is expected to have type
-  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} 𝕆] [_inst_3 : GradeOrder.{u2, u1} 𝕆 α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))] {a : α} {b : α}, Iff (LE.le.{u2} 𝕆 (Preorder.toLE.{u2} 𝕆 _inst_2) (grade.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2 _inst_3 a) (grade.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2 _inst_3 b)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)
-Case conversion may be inaccurate. Consider using '#align grade_le_grade_iff grade_le_grade_iffₓ'. -/
 @[simp]
 theorem grade_le_grade_iff : grade 𝕆 a ≤ grade 𝕆 b ↔ a ≤ b :=
   grade_strictMono.le_iff_le
 #align grade_le_grade_iff grade_le_grade_iff
 
-/- warning: grade_lt_grade_iff -> grade_lt_grade_iff is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))] {a : α} {b : α}, Iff (LT.lt.{u1} 𝕆 (Preorder.toHasLt.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 b)) (LT.lt.{u2} α (Preorder.toHasLt.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))) a b)
-but is expected to have type
-  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} 𝕆] [_inst_3 : GradeOrder.{u2, u1} 𝕆 α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))] {a : α} {b : α}, Iff (LT.lt.{u2} 𝕆 (Preorder.toLT.{u2} 𝕆 _inst_2) (grade.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2 _inst_3 a) (grade.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2 _inst_3 b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)
-Case conversion may be inaccurate. Consider using '#align grade_lt_grade_iff grade_lt_grade_iffₓ'. -/
 @[simp]
 theorem grade_lt_grade_iff : grade 𝕆 a < grade 𝕆 b ↔ a < b :=
   grade_strictMono.lt_iff_lt
 #align grade_lt_grade_iff grade_lt_grade_iff
 
-/- warning: grade_eq_grade_iff -> grade_eq_grade_iff is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))] {a : α} {b : α}, Iff (Eq.{succ u1} 𝕆 (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 b)) (Eq.{succ u2} α a b)
-but is expected to have type
-  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} 𝕆] [_inst_3 : GradeOrder.{u2, u1} 𝕆 α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))] {a : α} {b : α}, Iff (Eq.{succ u2} 𝕆 (grade.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2 _inst_3 a) (grade.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2 _inst_3 b)) (Eq.{succ u1} α a b)
-Case conversion may be inaccurate. Consider using '#align grade_eq_grade_iff grade_eq_grade_iffₓ'. -/
 @[simp]
 theorem grade_eq_grade_iff : grade 𝕆 a = grade 𝕆 b ↔ a = b :=
   grade_injective.eq_iff
 #align grade_eq_grade_iff grade_eq_grade_iff
 
-/- warning: grade_ne_grade_iff -> grade_ne_grade_iff is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))] {a : α} {b : α}, Iff (Ne.{succ u1} 𝕆 (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 b)) (Ne.{succ u2} α a b)
-but is expected to have type
-  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} 𝕆] [_inst_3 : GradeOrder.{u2, u1} 𝕆 α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))] {a : α} {b : α}, Iff (Ne.{succ u2} 𝕆 (grade.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2 _inst_3 a) (grade.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2 _inst_3 b)) (Ne.{succ u1} α a b)
-Case conversion may be inaccurate. Consider using '#align grade_ne_grade_iff grade_ne_grade_iffₓ'. -/
 theorem grade_ne_grade_iff : grade 𝕆 a ≠ grade 𝕆 b ↔ a ≠ b :=
   grade_injective.ne_iff
 #align grade_ne_grade_iff grade_ne_grade_iff
 
-/- warning: grade_covby_grade_iff -> grade_covby_grade_iff is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))] {a : α} {b : α}, Iff (Covby.{u1} 𝕆 (Preorder.toHasLt.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 b)) (Covby.{u2} α (Preorder.toHasLt.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))) a b)
-but is expected to have type
-  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} 𝕆] [_inst_3 : GradeOrder.{u2, u1} 𝕆 α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))] {a : α} {b : α}, Iff (Covby.{u2} 𝕆 (Preorder.toLT.{u2} 𝕆 _inst_2) (grade.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2 _inst_3 a) (grade.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2 _inst_3 b)) (Covby.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)
-Case conversion may be inaccurate. Consider using '#align grade_covby_grade_iff grade_covby_grade_iffₓ'. -/
 theorem grade_covby_grade_iff : grade 𝕆 a ⋖ grade 𝕆 b ↔ a ⋖ b :=
   (covby_iff_lt_covby_grade.trans <| and_iff_right_of_imp fun h => grade_lt_grade_iff.1 h.1).symm
 #align grade_covby_grade_iff grade_covby_grade_iff
@@ -312,23 +222,11 @@ section PartialOrder
 
 variable [PartialOrder 𝕆] [Preorder α]
 
-/- warning: grade_bot -> grade_bot is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : PartialOrder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : OrderBot.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 (PartialOrder.toPreorder.{u1} 𝕆 _inst_1))] [_inst_4 : OrderBot.{u2} α (Preorder.toHasLe.{u2} α _inst_2)] [_inst_5 : GradeMinOrder.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2], Eq.{succ u1} 𝕆 (grade.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2 (GradeMinOrder.toGradeOrder.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2 _inst_5) (Bot.bot.{u2} α (OrderBot.toHasBot.{u2} α (Preorder.toHasLe.{u2} α _inst_2) _inst_4))) (Bot.bot.{u1} 𝕆 (OrderBot.toHasBot.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 (PartialOrder.toPreorder.{u1} 𝕆 _inst_1)) _inst_3))
-but is expected to have type
-  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : PartialOrder.{u2} 𝕆] [_inst_2 : Preorder.{u1} α] [_inst_3 : OrderBot.{u2} 𝕆 (Preorder.toLE.{u2} 𝕆 (PartialOrder.toPreorder.{u2} 𝕆 _inst_1))] [_inst_4 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_2)] [_inst_5 : GradeMinOrder.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u2} 𝕆 _inst_1) _inst_2], Eq.{succ u2} 𝕆 (grade.{u2, u1} 𝕆 α _inst_2 (PartialOrder.toPreorder.{u2} 𝕆 _inst_1) (GradeMinOrder.toGradeOrder.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u2} 𝕆 _inst_1) _inst_2 _inst_5) (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_2) _inst_4))) (Bot.bot.{u2} 𝕆 (OrderBot.toBot.{u2} 𝕆 (Preorder.toLE.{u2} 𝕆 (PartialOrder.toPreorder.{u2} 𝕆 _inst_1)) _inst_3))
-Case conversion may be inaccurate. Consider using '#align grade_bot grade_botₓ'. -/
 @[simp]
 theorem grade_bot [OrderBot 𝕆] [OrderBot α] [GradeMinOrder 𝕆 α] : grade 𝕆 (⊥ : α) = ⊥ :=
   (isMin_bot.grade _).eq_bot
 #align grade_bot grade_bot
 
-/- warning: grade_top -> grade_top is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : PartialOrder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : OrderTop.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 (PartialOrder.toPreorder.{u1} 𝕆 _inst_1))] [_inst_4 : OrderTop.{u2} α (Preorder.toHasLe.{u2} α _inst_2)] [_inst_5 : GradeMaxOrder.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2], Eq.{succ u1} 𝕆 (grade.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2 (GradeMaxOrder.toGradeOrder.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2 _inst_5) (Top.top.{u2} α (OrderTop.toHasTop.{u2} α (Preorder.toHasLe.{u2} α _inst_2) _inst_4))) (Top.top.{u1} 𝕆 (OrderTop.toHasTop.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 (PartialOrder.toPreorder.{u1} 𝕆 _inst_1)) _inst_3))
-but is expected to have type
-  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : PartialOrder.{u2} 𝕆] [_inst_2 : Preorder.{u1} α] [_inst_3 : OrderTop.{u2} 𝕆 (Preorder.toLE.{u2} 𝕆 (PartialOrder.toPreorder.{u2} 𝕆 _inst_1))] [_inst_4 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_2)] [_inst_5 : GradeMaxOrder.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u2} 𝕆 _inst_1) _inst_2], Eq.{succ u2} 𝕆 (grade.{u2, u1} 𝕆 α _inst_2 (PartialOrder.toPreorder.{u2} 𝕆 _inst_1) (GradeMaxOrder.toGradeOrder.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u2} 𝕆 _inst_1) _inst_2 _inst_5) (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_2) _inst_4))) (Top.top.{u2} 𝕆 (OrderTop.toTop.{u2} 𝕆 (Preorder.toLE.{u2} 𝕆 (PartialOrder.toPreorder.{u2} 𝕆 _inst_1)) _inst_3))
-Case conversion may be inaccurate. Consider using '#align grade_top grade_topₓ'. -/
 @[simp]
 theorem grade_top [OrderTop 𝕆] [OrderTop α] [GradeMaxOrder 𝕆 α] : grade 𝕆 (⊤ : α) = ⊤ :=
   (isMax_top.grade _).eq_top
@@ -377,23 +275,11 @@ instance [GradeMinOrder 𝕆 α] : GradeMaxOrder 𝕆ᵒᵈ αᵒᵈ :=
 instance [GradeBoundedOrder 𝕆 α] : GradeBoundedOrder 𝕆ᵒᵈ αᵒᵈ :=
   { OrderDual.gradeMinOrder, OrderDual.gradeMaxOrder with }
 
-/- warning: grade_to_dual -> grade_toDual is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_5 : GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_3] (a : α), Eq.{succ u1} (OrderDual.{u1} 𝕆) (grade.{u1, u2} (OrderDual.{u1} 𝕆) (OrderDual.{u2} α) (OrderDual.preorder.{u1} 𝕆 _inst_1) (OrderDual.preorder.{u2} α _inst_3) (OrderDual.gradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_3 _inst_5) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} α (OrderDual.{u2} α)) (fun (_x : Equiv.{succ u2, succ u2} α (OrderDual.{u2} α)) => α -> (OrderDual.{u2} α)) (Equiv.hasCoeToFun.{succ u2, succ u2} α (OrderDual.{u2} α)) (OrderDual.toDual.{u2} α) a)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} 𝕆 (OrderDual.{u1} 𝕆)) (fun (_x : Equiv.{succ u1, succ u1} 𝕆 (OrderDual.{u1} 𝕆)) => 𝕆 -> (OrderDual.{u1} 𝕆)) (Equiv.hasCoeToFun.{succ u1, succ u1} 𝕆 (OrderDual.{u1} 𝕆)) (OrderDual.toDual.{u1} 𝕆) (grade.{u1, u2} 𝕆 α _inst_1 _inst_3 _inst_5 a))
-but is expected to have type
-  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : Preorder.{u2} 𝕆] [_inst_3 : Preorder.{u1} α] [_inst_5 : GradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3] (a : α), Eq.{succ u2} (OrderDual.{u2} 𝕆) (grade.{u2, u1} (OrderDual.{u2} 𝕆) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => OrderDual.{u1} α) a) (OrderDual.preorder.{u1} α _inst_3) (OrderDual.preorder.{u2} 𝕆 _inst_1) (OrderDual.gradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3 _inst_5) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} 𝕆 (OrderDual.{u2} 𝕆)) 𝕆 (fun (_x : 𝕆) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : 𝕆) => OrderDual.{u2} 𝕆) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} 𝕆 (OrderDual.{u2} 𝕆)) (OrderDual.toDual.{u2} 𝕆) (grade.{u2, u1} 𝕆 α _inst_3 _inst_1 _inst_5 a))
-Case conversion may be inaccurate. Consider using '#align grade_to_dual grade_toDualₓ'. -/
 @[simp]
 theorem grade_toDual [GradeOrder 𝕆 α] (a : α) : grade 𝕆ᵒᵈ (toDual a) = toDual (grade 𝕆 a) :=
   rfl
 #align grade_to_dual grade_toDual
 
-/- warning: grade_of_dual -> grade_ofDual is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_5 : GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_3] (a : OrderDual.{u2} α), Eq.{succ u1} 𝕆 (grade.{u1, u2} 𝕆 α _inst_1 _inst_3 _inst_5 (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (fun (_x : Equiv.{succ u2, succ u2} (OrderDual.{u2} α) α) => (OrderDual.{u2} α) -> α) (Equiv.hasCoeToFun.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.ofDual.{u2} α) a)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} 𝕆) 𝕆) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} 𝕆) 𝕆) => (OrderDual.{u1} 𝕆) -> 𝕆) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} 𝕆) 𝕆) (OrderDual.ofDual.{u1} 𝕆) (grade.{u1, u2} (OrderDual.{u1} 𝕆) (OrderDual.{u2} α) (OrderDual.preorder.{u1} 𝕆 _inst_1) (OrderDual.preorder.{u2} α _inst_3) (OrderDual.gradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_3 _inst_5) a))
-but is expected to have type
-  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : Preorder.{u2} 𝕆] [_inst_3 : Preorder.{u1} α] [_inst_5 : GradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3] (a : OrderDual.{u1} α), Eq.{succ u2} 𝕆 (grade.{u2, u1} 𝕆 ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} α) => α) a) _inst_3 _inst_1 _inst_5 (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} 𝕆) 𝕆) (OrderDual.{u2} 𝕆) (fun (_x : OrderDual.{u2} 𝕆) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u2} 𝕆) => 𝕆) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (OrderDual.{u2} 𝕆) 𝕆) (OrderDual.ofDual.{u2} 𝕆) (grade.{u2, u1} (OrderDual.{u2} 𝕆) (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_3) (OrderDual.preorder.{u2} 𝕆 _inst_1) (OrderDual.gradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3 _inst_5) a))
-Case conversion may be inaccurate. Consider using '#align grade_of_dual grade_ofDualₓ'. -/
 @[simp]
 theorem grade_ofDual [GradeOrder 𝕆 α] (a : αᵒᵈ) : grade 𝕆 (ofDual a) = ofDual (grade 𝕆ᵒᵈ a) :=
   rfl
@@ -402,12 +288,6 @@ theorem grade_ofDual [GradeOrder 𝕆 α] (a : αᵒᵈ) : grade 𝕆 (ofDual a)
 /-! #### Lifting a graded order -/
 
 
-/- warning: grade_order.lift_left -> GradeOrder.liftLeft is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {ℙ : Type.{u2}} {α : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} ℙ] [_inst_3 : Preorder.{u3} α] [_inst_5 : GradeOrder.{u1, u3} 𝕆 α _inst_1 _inst_3] (f : 𝕆 -> ℙ), (StrictMono.{u1, u2} 𝕆 ℙ _inst_1 _inst_2 f) -> (forall (a : 𝕆) (b : 𝕆), (Covby.{u1} 𝕆 (Preorder.toHasLt.{u1} 𝕆 _inst_1) a b) -> (Covby.{u2} ℙ (Preorder.toHasLt.{u2} ℙ _inst_2) (f a) (f b))) -> (GradeOrder.{u2, u3} ℙ α _inst_2 _inst_3)
-but is expected to have type
-  forall {𝕆 : Type.{u1}} {ℙ : Type.{u2}} {α : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} ℙ] [_inst_3 : Preorder.{u3} α] [_inst_5 : GradeOrder.{u1, u3} 𝕆 α _inst_1 _inst_3] (f : 𝕆 -> ℙ), (StrictMono.{u1, u2} 𝕆 ℙ _inst_1 _inst_2 f) -> (forall (a : 𝕆) (b : 𝕆), (Covby.{u1} 𝕆 (Preorder.toLT.{u1} 𝕆 _inst_1) a b) -> (Covby.{u2} ℙ (Preorder.toLT.{u2} ℙ _inst_2) (f a) (f b))) -> (GradeOrder.{u2, u3} ℙ α _inst_2 _inst_3)
-Case conversion may be inaccurate. Consider using '#align grade_order.lift_left GradeOrder.liftLeftₓ'. -/
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -419,12 +299,6 @@ def GradeOrder.liftLeft [GradeOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono
   covby_grade a b h := hcovby _ _ <| h.grade _
 #align grade_order.lift_left GradeOrder.liftLeft
 
-/- warning: grade_min_order.lift_left -> GradeMinOrder.liftLeft is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {ℙ : Type.{u2}} {α : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} ℙ] [_inst_3 : Preorder.{u3} α] [_inst_5 : GradeMinOrder.{u1, u3} 𝕆 α _inst_1 _inst_3] (f : 𝕆 -> ℙ), (StrictMono.{u1, u2} 𝕆 ℙ _inst_1 _inst_2 f) -> (forall (a : 𝕆) (b : 𝕆), (Covby.{u1} 𝕆 (Preorder.toHasLt.{u1} 𝕆 _inst_1) a b) -> (Covby.{u2} ℙ (Preorder.toHasLt.{u2} ℙ _inst_2) (f a) (f b))) -> (forall (a : 𝕆), (IsMin.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) a) -> (IsMin.{u2} ℙ (Preorder.toHasLe.{u2} ℙ _inst_2) (f a))) -> (GradeMinOrder.{u2, u3} ℙ α _inst_2 _inst_3)
-but is expected to have type
-  forall {𝕆 : Type.{u1}} {ℙ : Type.{u2}} {α : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} ℙ] [_inst_3 : Preorder.{u3} α] [_inst_5 : GradeMinOrder.{u1, u3} 𝕆 α _inst_1 _inst_3] (f : 𝕆 -> ℙ), (StrictMono.{u1, u2} 𝕆 ℙ _inst_1 _inst_2 f) -> (forall (a : 𝕆) (b : 𝕆), (Covby.{u1} 𝕆 (Preorder.toLT.{u1} 𝕆 _inst_1) a b) -> (Covby.{u2} ℙ (Preorder.toLT.{u2} ℙ _inst_2) (f a) (f b))) -> (forall (a : 𝕆), (IsMin.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_1) a) -> (IsMin.{u2} ℙ (Preorder.toLE.{u2} ℙ _inst_2) (f a))) -> (GradeMinOrder.{u2, u3} ℙ α _inst_2 _inst_3)
-Case conversion may be inaccurate. Consider using '#align grade_min_order.lift_left GradeMinOrder.liftLeftₓ'. -/
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -433,12 +307,6 @@ def GradeMinOrder.liftLeft [GradeMinOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : Stri
   { GradeOrder.liftLeft f hf hcovby with isMin_grade := fun a ha => hmin _ <| ha.grade _ }
 #align grade_min_order.lift_left GradeMinOrder.liftLeft
 
-/- warning: grade_max_order.lift_left -> GradeMaxOrder.liftLeft is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {ℙ : Type.{u2}} {α : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} ℙ] [_inst_3 : Preorder.{u3} α] [_inst_5 : GradeMaxOrder.{u1, u3} 𝕆 α _inst_1 _inst_3] (f : 𝕆 -> ℙ), (StrictMono.{u1, u2} 𝕆 ℙ _inst_1 _inst_2 f) -> (forall (a : 𝕆) (b : 𝕆), (Covby.{u1} 𝕆 (Preorder.toHasLt.{u1} 𝕆 _inst_1) a b) -> (Covby.{u2} ℙ (Preorder.toHasLt.{u2} ℙ _inst_2) (f a) (f b))) -> (forall (a : 𝕆), (IsMax.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) a) -> (IsMax.{u2} ℙ (Preorder.toHasLe.{u2} ℙ _inst_2) (f a))) -> (GradeMaxOrder.{u2, u3} ℙ α _inst_2 _inst_3)
-but is expected to have type
-  forall {𝕆 : Type.{u1}} {ℙ : Type.{u2}} {α : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} ℙ] [_inst_3 : Preorder.{u3} α] [_inst_5 : GradeMaxOrder.{u1, u3} 𝕆 α _inst_1 _inst_3] (f : 𝕆 -> ℙ), (StrictMono.{u1, u2} 𝕆 ℙ _inst_1 _inst_2 f) -> (forall (a : 𝕆) (b : 𝕆), (Covby.{u1} 𝕆 (Preorder.toLT.{u1} 𝕆 _inst_1) a b) -> (Covby.{u2} ℙ (Preorder.toLT.{u2} ℙ _inst_2) (f a) (f b))) -> (forall (a : 𝕆), (IsMax.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_1) a) -> (IsMax.{u2} ℙ (Preorder.toLE.{u2} ℙ _inst_2) (f a))) -> (GradeMaxOrder.{u2, u3} ℙ α _inst_2 _inst_3)
-Case conversion may be inaccurate. Consider using '#align grade_max_order.lift_left GradeMaxOrder.liftLeftₓ'. -/
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -447,12 +315,6 @@ def GradeMaxOrder.liftLeft [GradeMaxOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : Stri
   { GradeOrder.liftLeft f hf hcovby with isMax_grade := fun a ha => hmax _ <| ha.grade _ }
 #align grade_max_order.lift_left GradeMaxOrder.liftLeft
 
-/- warning: grade_bounded_order.lift_left -> GradeBoundedOrder.liftLeft is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {ℙ : Type.{u2}} {α : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} ℙ] [_inst_3 : Preorder.{u3} α] [_inst_5 : GradeBoundedOrder.{u1, u3} 𝕆 α _inst_1 _inst_3] (f : 𝕆 -> ℙ), (StrictMono.{u1, u2} 𝕆 ℙ _inst_1 _inst_2 f) -> (forall (a : 𝕆) (b : 𝕆), (Covby.{u1} 𝕆 (Preorder.toHasLt.{u1} 𝕆 _inst_1) a b) -> (Covby.{u2} ℙ (Preorder.toHasLt.{u2} ℙ _inst_2) (f a) (f b))) -> (forall (a : 𝕆), (IsMin.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) a) -> (IsMin.{u2} ℙ (Preorder.toHasLe.{u2} ℙ _inst_2) (f a))) -> (forall (a : 𝕆), (IsMax.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) a) -> (IsMax.{u2} ℙ (Preorder.toHasLe.{u2} ℙ _inst_2) (f a))) -> (GradeBoundedOrder.{u2, u3} ℙ α _inst_2 _inst_3)
-but is expected to have type
-  forall {𝕆 : Type.{u1}} {ℙ : Type.{u2}} {α : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} ℙ] [_inst_3 : Preorder.{u3} α] [_inst_5 : GradeBoundedOrder.{u1, u3} 𝕆 α _inst_1 _inst_3] (f : 𝕆 -> ℙ), (StrictMono.{u1, u2} 𝕆 ℙ _inst_1 _inst_2 f) -> (forall (a : 𝕆) (b : 𝕆), (Covby.{u1} 𝕆 (Preorder.toLT.{u1} 𝕆 _inst_1) a b) -> (Covby.{u2} ℙ (Preorder.toLT.{u2} ℙ _inst_2) (f a) (f b))) -> (forall (a : 𝕆), (IsMin.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_1) a) -> (IsMin.{u2} ℙ (Preorder.toLE.{u2} ℙ _inst_2) (f a))) -> (forall (a : 𝕆), (IsMax.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_1) a) -> (IsMax.{u2} ℙ (Preorder.toLE.{u2} ℙ _inst_2) (f a))) -> (GradeBoundedOrder.{u2, u3} ℙ α _inst_2 _inst_3)
-Case conversion may be inaccurate. Consider using '#align grade_bounded_order.lift_left GradeBoundedOrder.liftLeftₓ'. -/
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -462,12 +324,6 @@ def GradeBoundedOrder.liftLeft [GradeBoundedOrder 𝕆 α] (f : 𝕆 → ℙ) (h
   { GradeMinOrder.liftLeft f hf hcovby hmin, GradeMaxOrder.liftLeft f hf hcovby hmax with }
 #align grade_bounded_order.lift_left GradeBoundedOrder.liftLeft
 
-/- warning: grade_order.lift_right -> GradeOrder.liftRight is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_4 : Preorder.{u3} β] [_inst_5 : GradeOrder.{u1, u3} 𝕆 β _inst_1 _inst_4] (f : α -> β), (StrictMono.{u2, u3} α β _inst_3 _inst_4 f) -> (forall (a : α) (b : α), (Covby.{u2} α (Preorder.toHasLt.{u2} α _inst_3) a b) -> (Covby.{u3} β (Preorder.toHasLt.{u3} β _inst_4) (f a) (f b))) -> (GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_3)
-but is expected to have type
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_4 : Preorder.{u3} β] [_inst_5 : GradeOrder.{u1, u3} 𝕆 β _inst_1 _inst_4] (f : α -> β), (StrictMono.{u2, u3} α β _inst_3 _inst_4 f) -> (forall (a : α) (b : α), (Covby.{u2} α (Preorder.toLT.{u2} α _inst_3) a b) -> (Covby.{u3} β (Preorder.toLT.{u3} β _inst_4) (f a) (f b))) -> (GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_3)
-Case conversion may be inaccurate. Consider using '#align grade_order.lift_right GradeOrder.liftRightₓ'. -/
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -479,12 +335,6 @@ def GradeOrder.liftRight [GradeOrder 𝕆 β] (f : α → β) (hf : StrictMono f
   covby_grade a b h := (hcovby _ _ h).grade _
 #align grade_order.lift_right GradeOrder.liftRight
 
-/- warning: grade_min_order.lift_right -> GradeMinOrder.liftRight is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_4 : Preorder.{u3} β] [_inst_5 : GradeMinOrder.{u1, u3} 𝕆 β _inst_1 _inst_4] (f : α -> β), (StrictMono.{u2, u3} α β _inst_3 _inst_4 f) -> (forall (a : α) (b : α), (Covby.{u2} α (Preorder.toHasLt.{u2} α _inst_3) a b) -> (Covby.{u3} β (Preorder.toHasLt.{u3} β _inst_4) (f a) (f b))) -> (forall (a : α), (IsMin.{u2} α (Preorder.toHasLe.{u2} α _inst_3) a) -> (IsMin.{u3} β (Preorder.toHasLe.{u3} β _inst_4) (f a))) -> (GradeMinOrder.{u1, u2} 𝕆 α _inst_1 _inst_3)
-but is expected to have type
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_4 : Preorder.{u3} β] [_inst_5 : GradeMinOrder.{u1, u3} 𝕆 β _inst_1 _inst_4] (f : α -> β), (StrictMono.{u2, u3} α β _inst_3 _inst_4 f) -> (forall (a : α) (b : α), (Covby.{u2} α (Preorder.toLT.{u2} α _inst_3) a b) -> (Covby.{u3} β (Preorder.toLT.{u3} β _inst_4) (f a) (f b))) -> (forall (a : α), (IsMin.{u2} α (Preorder.toLE.{u2} α _inst_3) a) -> (IsMin.{u3} β (Preorder.toLE.{u3} β _inst_4) (f a))) -> (GradeMinOrder.{u1, u2} 𝕆 α _inst_1 _inst_3)
-Case conversion may be inaccurate. Consider using '#align grade_min_order.lift_right GradeMinOrder.liftRightₓ'. -/
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -493,12 +343,6 @@ def GradeMinOrder.liftRight [GradeMinOrder 𝕆 β] (f : α → β) (hf : Strict
   { GradeOrder.liftRight f hf hcovby with isMin_grade := fun a ha => (hmin _ ha).grade _ }
 #align grade_min_order.lift_right GradeMinOrder.liftRight
 
-/- warning: grade_max_order.lift_right -> GradeMaxOrder.liftRight is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_4 : Preorder.{u3} β] [_inst_5 : GradeMaxOrder.{u1, u3} 𝕆 β _inst_1 _inst_4] (f : α -> β), (StrictMono.{u2, u3} α β _inst_3 _inst_4 f) -> (forall (a : α) (b : α), (Covby.{u2} α (Preorder.toHasLt.{u2} α _inst_3) a b) -> (Covby.{u3} β (Preorder.toHasLt.{u3} β _inst_4) (f a) (f b))) -> (forall (a : α), (IsMax.{u2} α (Preorder.toHasLe.{u2} α _inst_3) a) -> (IsMax.{u3} β (Preorder.toHasLe.{u3} β _inst_4) (f a))) -> (GradeMaxOrder.{u1, u2} 𝕆 α _inst_1 _inst_3)
-but is expected to have type
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_4 : Preorder.{u3} β] [_inst_5 : GradeMaxOrder.{u1, u3} 𝕆 β _inst_1 _inst_4] (f : α -> β), (StrictMono.{u2, u3} α β _inst_3 _inst_4 f) -> (forall (a : α) (b : α), (Covby.{u2} α (Preorder.toLT.{u2} α _inst_3) a b) -> (Covby.{u3} β (Preorder.toLT.{u3} β _inst_4) (f a) (f b))) -> (forall (a : α), (IsMax.{u2} α (Preorder.toLE.{u2} α _inst_3) a) -> (IsMax.{u3} β (Preorder.toLE.{u3} β _inst_4) (f a))) -> (GradeMaxOrder.{u1, u2} 𝕆 α _inst_1 _inst_3)
-Case conversion may be inaccurate. Consider using '#align grade_max_order.lift_right GradeMaxOrder.liftRightₓ'. -/
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -507,12 +351,6 @@ def GradeMaxOrder.liftRight [GradeMaxOrder 𝕆 β] (f : α → β) (hf : Strict
   { GradeOrder.liftRight f hf hcovby with isMax_grade := fun a ha => (hmax _ ha).grade _ }
 #align grade_max_order.lift_right GradeMaxOrder.liftRight
 
-/- warning: grade_bounded_order.lift_right -> GradeBoundedOrder.liftRight is a dubious translation:
-lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_4 : Preorder.{u3} β] [_inst_5 : GradeBoundedOrder.{u1, u3} 𝕆 β _inst_1 _inst_4] (f : α -> β), (StrictMono.{u2, u3} α β _inst_3 _inst_4 f) -> (forall (a : α) (b : α), (Covby.{u2} α (Preorder.toHasLt.{u2} α _inst_3) a b) -> (Covby.{u3} β (Preorder.toHasLt.{u3} β _inst_4) (f a) (f b))) -> (forall (a : α), (IsMin.{u2} α (Preorder.toHasLe.{u2} α _inst_3) a) -> (IsMin.{u3} β (Preorder.toHasLe.{u3} β _inst_4) (f a))) -> (forall (a : α), (IsMax.{u2} α (Preorder.toHasLe.{u2} α _inst_3) a) -> (IsMax.{u3} β (Preorder.toHasLe.{u3} β _inst_4) (f a))) -> (GradeBoundedOrder.{u1, u2} 𝕆 α _inst_1 _inst_3)
-but is expected to have type
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_4 : Preorder.{u3} β] [_inst_5 : GradeBoundedOrder.{u1, u3} 𝕆 β _inst_1 _inst_4] (f : α -> β), (StrictMono.{u2, u3} α β _inst_3 _inst_4 f) -> (forall (a : α) (b : α), (Covby.{u2} α (Preorder.toLT.{u2} α _inst_3) a b) -> (Covby.{u3} β (Preorder.toLT.{u3} β _inst_4) (f a) (f b))) -> (forall (a : α), (IsMin.{u2} α (Preorder.toLE.{u2} α _inst_3) a) -> (IsMin.{u3} β (Preorder.toLE.{u3} β _inst_4) (f a))) -> (forall (a : α), (IsMax.{u2} α (Preorder.toLE.{u2} α _inst_3) a) -> (IsMax.{u3} β (Preorder.toLE.{u3} β _inst_4) (f a))) -> (GradeBoundedOrder.{u1, u2} 𝕆 α _inst_1 _inst_3)
-Case conversion may be inaccurate. Consider using '#align grade_bounded_order.lift_right GradeBoundedOrder.liftRightₓ'. -/
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -525,12 +363,6 @@ def GradeBoundedOrder.liftRight [GradeBoundedOrder 𝕆 β] (f : α → β) (hf
 /-! #### `fin n`-graded to `ℕ`-graded to `ℤ`-graded -/
 
 
-/- warning: grade_order.fin_to_nat -> GradeOrder.finToNat is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_3 : Preorder.{u1} α] (n : Nat) [_inst_5 : GradeOrder.{0, u1} (Fin n) α (PartialOrder.toPreorder.{0} (Fin n) (Fin.partialOrder n)) _inst_3], GradeOrder.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) _inst_3
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_3 : Preorder.{u1} α] (n : Nat) [_inst_5 : GradeOrder.{0, u1} (Fin n) α (PartialOrder.toPreorder.{0} (Fin n) (Fin.instPartialOrderFin n)) _inst_3], GradeOrder.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) _inst_3
-Case conversion may be inaccurate. Consider using '#align grade_order.fin_to_nat GradeOrder.finToNatₓ'. -/
 -- See note [reducible non-instances]
 /-- A `fin n`-graded order is also `ℕ`-graded. We do not mark this an instance because `n` is not
 inferrable. -/
@@ -539,12 +371,6 @@ def GradeOrder.finToNat (n : ℕ) [GradeOrder (Fin n) α] : GradeOrder ℕ α :=
   GradeOrder.liftLeft (_ : Fin n → ℕ) Fin.val_strictMono fun _ _ => Covby.coe_fin
 #align grade_order.fin_to_nat GradeOrder.finToNat
 
-/- warning: grade_min_order.fin_to_nat -> GradeMinOrder.finToNat is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_3 : Preorder.{u1} α] (n : Nat) [_inst_5 : GradeMinOrder.{0, u1} (Fin n) α (PartialOrder.toPreorder.{0} (Fin n) (Fin.partialOrder n)) _inst_3], GradeMinOrder.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) _inst_3
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_3 : Preorder.{u1} α] (n : Nat) [_inst_5 : GradeMinOrder.{0, u1} (Fin n) α (PartialOrder.toPreorder.{0} (Fin n) (Fin.instPartialOrderFin n)) _inst_3], GradeMinOrder.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) _inst_3
-Case conversion may be inaccurate. Consider using '#align grade_min_order.fin_to_nat GradeMinOrder.finToNatₓ'. -/
 -- See note [reducible non-instances]
 /-- A `fin n`-graded order is also `ℕ`-graded. We do not mark this an instance because `n` is not
 inferrable. -/

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

@@ -381,7 +381,7 @@ instance [GradeBoundedOrder 𝕆 α] : GradeBoundedOrder 𝕆ᵒᵈ αᵒᵈ :=
 lean 3 declaration is
   forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_5 : GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_3] (a : α), Eq.{succ u1} (OrderDual.{u1} 𝕆) (grade.{u1, u2} (OrderDual.{u1} 𝕆) (OrderDual.{u2} α) (OrderDual.preorder.{u1} 𝕆 _inst_1) (OrderDual.preorder.{u2} α _inst_3) (OrderDual.gradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_3 _inst_5) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} α (OrderDual.{u2} α)) (fun (_x : Equiv.{succ u2, succ u2} α (OrderDual.{u2} α)) => α -> (OrderDual.{u2} α)) (Equiv.hasCoeToFun.{succ u2, succ u2} α (OrderDual.{u2} α)) (OrderDual.toDual.{u2} α) a)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} 𝕆 (OrderDual.{u1} 𝕆)) (fun (_x : Equiv.{succ u1, succ u1} 𝕆 (OrderDual.{u1} 𝕆)) => 𝕆 -> (OrderDual.{u1} 𝕆)) (Equiv.hasCoeToFun.{succ u1, succ u1} 𝕆 (OrderDual.{u1} 𝕆)) (OrderDual.toDual.{u1} 𝕆) (grade.{u1, u2} 𝕆 α _inst_1 _inst_3 _inst_5 a))
 but is expected to have type
-  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : Preorder.{u2} 𝕆] [_inst_3 : Preorder.{u1} α] [_inst_5 : GradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3] (a : α), Eq.{succ u2} (OrderDual.{u2} 𝕆) (grade.{u2, u1} (OrderDual.{u2} 𝕆) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u1} α) a) (OrderDual.preorder.{u1} α _inst_3) (OrderDual.preorder.{u2} 𝕆 _inst_1) (OrderDual.gradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3 _inst_5) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} 𝕆 (OrderDual.{u2} 𝕆)) 𝕆 (fun (_x : 𝕆) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : 𝕆) => OrderDual.{u2} 𝕆) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} 𝕆 (OrderDual.{u2} 𝕆)) (OrderDual.toDual.{u2} 𝕆) (grade.{u2, u1} 𝕆 α _inst_3 _inst_1 _inst_5 a))
+  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : Preorder.{u2} 𝕆] [_inst_3 : Preorder.{u1} α] [_inst_5 : GradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3] (a : α), Eq.{succ u2} (OrderDual.{u2} 𝕆) (grade.{u2, u1} (OrderDual.{u2} 𝕆) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => OrderDual.{u1} α) a) (OrderDual.preorder.{u1} α _inst_3) (OrderDual.preorder.{u2} 𝕆 _inst_1) (OrderDual.gradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3 _inst_5) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} 𝕆 (OrderDual.{u2} 𝕆)) 𝕆 (fun (_x : 𝕆) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : 𝕆) => OrderDual.{u2} 𝕆) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} 𝕆 (OrderDual.{u2} 𝕆)) (OrderDual.toDual.{u2} 𝕆) (grade.{u2, u1} 𝕆 α _inst_3 _inst_1 _inst_5 a))
 Case conversion may be inaccurate. Consider using '#align grade_to_dual grade_toDualₓ'. -/
 @[simp]
 theorem grade_toDual [GradeOrder 𝕆 α] (a : α) : grade 𝕆ᵒᵈ (toDual a) = toDual (grade 𝕆 a) :=
@@ -392,7 +392,7 @@ theorem grade_toDual [GradeOrder 𝕆 α] (a : α) : grade 𝕆ᵒᵈ (toDual a)
 lean 3 declaration is
   forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_5 : GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_3] (a : OrderDual.{u2} α), Eq.{succ u1} 𝕆 (grade.{u1, u2} 𝕆 α _inst_1 _inst_3 _inst_5 (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (fun (_x : Equiv.{succ u2, succ u2} (OrderDual.{u2} α) α) => (OrderDual.{u2} α) -> α) (Equiv.hasCoeToFun.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.ofDual.{u2} α) a)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} 𝕆) 𝕆) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} 𝕆) 𝕆) => (OrderDual.{u1} 𝕆) -> 𝕆) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} 𝕆) 𝕆) (OrderDual.ofDual.{u1} 𝕆) (grade.{u1, u2} (OrderDual.{u1} 𝕆) (OrderDual.{u2} α) (OrderDual.preorder.{u1} 𝕆 _inst_1) (OrderDual.preorder.{u2} α _inst_3) (OrderDual.gradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_3 _inst_5) a))
 but is expected to have type
-  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : Preorder.{u2} 𝕆] [_inst_3 : Preorder.{u1} α] [_inst_5 : GradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3] (a : OrderDual.{u1} α), Eq.{succ u2} 𝕆 (grade.{u2, u1} 𝕆 ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} α) => α) a) _inst_3 _inst_1 _inst_5 (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} 𝕆) 𝕆) (OrderDual.{u2} 𝕆) (fun (_x : OrderDual.{u2} 𝕆) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u2} 𝕆) => 𝕆) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (OrderDual.{u2} 𝕆) 𝕆) (OrderDual.ofDual.{u2} 𝕆) (grade.{u2, u1} (OrderDual.{u2} 𝕆) (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_3) (OrderDual.preorder.{u2} 𝕆 _inst_1) (OrderDual.gradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3 _inst_5) a))
+  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : Preorder.{u2} 𝕆] [_inst_3 : Preorder.{u1} α] [_inst_5 : GradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3] (a : OrderDual.{u1} α), Eq.{succ u2} 𝕆 (grade.{u2, u1} 𝕆 ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} α) => α) a) _inst_3 _inst_1 _inst_5 (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} 𝕆) 𝕆) (OrderDual.{u2} 𝕆) (fun (_x : OrderDual.{u2} 𝕆) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u2} 𝕆) => 𝕆) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (OrderDual.{u2} 𝕆) 𝕆) (OrderDual.ofDual.{u2} 𝕆) (grade.{u2, u1} (OrderDual.{u2} 𝕆) (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_3) (OrderDual.preorder.{u2} 𝕆 _inst_1) (OrderDual.gradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3 _inst_5) a))
 Case conversion may be inaccurate. Consider using '#align grade_of_dual grade_ofDualₓ'. -/
 @[simp]
 theorem grade_ofDual [GradeOrder 𝕆 α] (a : αᵒᵈ) : grade 𝕆 (ofDual a) = ofDual (grade 𝕆ᵒᵈ a) :=

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

@@ -130,7 +130,7 @@ def grade : α → 𝕆 :=
 
 /- warning: covby.grade -> Covby.grade is a dubious translation:
 lean 3 declaration is
-  forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α} {b : α}, (Covby.{u2} α (Preorder.toLT.{u2} α _inst_2) a b) -> (Covby.{u1} 𝕆 (Preorder.toLT.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 b))
+  forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α} {b : α}, (Covby.{u2} α (Preorder.toHasLt.{u2} α _inst_2) a b) -> (Covby.{u1} 𝕆 (Preorder.toHasLt.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 b))
 but is expected to have type
   forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} 𝕆] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_2 _inst_1] {a : α} {b : α}, (Covby.{u2} α (Preorder.toLT.{u2} α _inst_1) a b) -> (Covby.{u1} 𝕆 (Preorder.toLT.{u1} 𝕆 _inst_2) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 b))
 Case conversion may be inaccurate. Consider using '#align covby.grade Covby.gradeₓ'. -/
@@ -152,7 +152,7 @@ theorem grade_strictMono : StrictMono (grade 𝕆 : α → 𝕆) :=
 
 /- warning: covby_iff_lt_covby_grade -> covby_iff_lt_covby_grade is a dubious translation:
 lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α} {b : α}, Iff (Covby.{u2} α (Preorder.toLT.{u2} α _inst_2) a b) (And (LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) a b) (Covby.{u1} 𝕆 (Preorder.toLT.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 b)))
+  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α} {b : α}, Iff (Covby.{u2} α (Preorder.toHasLt.{u2} α _inst_2) a b) (And (LT.lt.{u2} α (Preorder.toHasLt.{u2} α _inst_2) a b) (Covby.{u1} 𝕆 (Preorder.toHasLt.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 b)))
 but is expected to have type
   forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} 𝕆] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_2 _inst_1] {a : α} {b : α}, Iff (Covby.{u2} α (Preorder.toLT.{u2} α _inst_1) a b) (And (LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_1) a b) (Covby.{u1} 𝕆 (Preorder.toLT.{u1} 𝕆 _inst_2) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3 b)))
 Case conversion may be inaccurate. Consider using '#align covby_iff_lt_covby_grade covby_iff_lt_covby_gradeₓ'. -/
@@ -169,7 +169,7 @@ variable (𝕆) [GradeMinOrder 𝕆 α] {a : α}
 
 /- warning: is_min.grade -> IsMin.grade is a dubious translation:
 lean 3 declaration is
-  forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeMinOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α}, (IsMin.{u2} α (Preorder.toLE.{u2} α _inst_2) a) -> (IsMin.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 (GradeMinOrder.toGradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3) a))
+  forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeMinOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α}, (IsMin.{u2} α (Preorder.toHasLe.{u2} α _inst_2) a) -> (IsMin.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 (GradeMinOrder.toGradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3) a))
 but is expected to have type
   forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} 𝕆] [_inst_3 : GradeMinOrder.{u1, u2} 𝕆 α _inst_2 _inst_1] {a : α}, (IsMin.{u2} α (Preorder.toLE.{u2} α _inst_1) a) -> (IsMin.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_2) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 (GradeMinOrder.toGradeOrder.{u1, u2} 𝕆 α _inst_2 _inst_1 _inst_3) a))
 Case conversion may be inaccurate. Consider using '#align is_min.grade IsMin.gradeₓ'. -/
@@ -181,7 +181,7 @@ variable {𝕆}
 
 /- warning: is_min_grade_iff -> isMin_grade_iff is a dubious translation:
 lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeMinOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α}, Iff (IsMin.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 (GradeMinOrder.toGradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3) a)) (IsMin.{u2} α (Preorder.toLE.{u2} α _inst_2) a)
+  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeMinOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α}, Iff (IsMin.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 (GradeMinOrder.toGradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3) a)) (IsMin.{u2} α (Preorder.toHasLe.{u2} α _inst_2) a)
 but is expected to have type
   forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} 𝕆] [_inst_3 : GradeMinOrder.{u2, u1} 𝕆 α _inst_2 _inst_1] {a : α}, Iff (IsMin.{u2} 𝕆 (Preorder.toLE.{u2} 𝕆 _inst_2) (grade.{u2, u1} 𝕆 α _inst_1 _inst_2 (GradeMinOrder.toGradeOrder.{u2, u1} 𝕆 α _inst_2 _inst_1 _inst_3) a)) (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
 Case conversion may be inaccurate. Consider using '#align is_min_grade_iff isMin_grade_iffₓ'. -/
@@ -198,7 +198,7 @@ variable (𝕆) [GradeMaxOrder 𝕆 α] {a : α}
 
 /- warning: is_max.grade -> IsMax.grade is a dubious translation:
 lean 3 declaration is
-  forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeMaxOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α}, (IsMax.{u2} α (Preorder.toLE.{u2} α _inst_2) a) -> (IsMax.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 (GradeMaxOrder.toGradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3) a))
+  forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeMaxOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α}, (IsMax.{u2} α (Preorder.toHasLe.{u2} α _inst_2) a) -> (IsMax.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 (GradeMaxOrder.toGradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3) a))
 but is expected to have type
   forall (𝕆 : Type.{u1}) {α : Type.{u2}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} 𝕆] [_inst_3 : GradeMaxOrder.{u1, u2} 𝕆 α _inst_2 _inst_1] {a : α}, (IsMax.{u2} α (Preorder.toLE.{u2} α _inst_1) a) -> (IsMax.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_2) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 (GradeMaxOrder.toGradeOrder.{u1, u2} 𝕆 α _inst_2 _inst_1 _inst_3) a))
 Case conversion may be inaccurate. Consider using '#align is_max.grade IsMax.gradeₓ'. -/
@@ -210,7 +210,7 @@ variable {𝕆}
 
 /- warning: is_max_grade_iff -> isMax_grade_iff is a dubious translation:
 lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeMaxOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α}, Iff (IsMax.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 (GradeMaxOrder.toGradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3) a)) (IsMax.{u2} α (Preorder.toLE.{u2} α _inst_2) a)
+  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : GradeMaxOrder.{u1, u2} 𝕆 α _inst_1 _inst_2] {a : α}, Iff (IsMax.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 _inst_2 (GradeMaxOrder.toGradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_2 _inst_3) a)) (IsMax.{u2} α (Preorder.toHasLe.{u2} α _inst_2) a)
 but is expected to have type
   forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} 𝕆] [_inst_3 : GradeMaxOrder.{u2, u1} 𝕆 α _inst_2 _inst_1] {a : α}, Iff (IsMax.{u2} 𝕆 (Preorder.toLE.{u2} 𝕆 _inst_2) (grade.{u2, u1} 𝕆 α _inst_1 _inst_2 (GradeMaxOrder.toGradeOrder.{u2, u1} 𝕆 α _inst_2 _inst_1 _inst_3) a)) (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
 Case conversion may be inaccurate. Consider using '#align is_max_grade_iff isMax_grade_iffₓ'. -/
@@ -251,7 +251,7 @@ theorem grade_injective : Function.Injective (grade 𝕆 : α → 𝕆) :=
 
 /- warning: grade_le_grade_iff -> grade_le_grade_iff is a dubious translation:
 lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))] {a : α} {b : α}, Iff (LE.le.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 b)) (LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))) a b)
+  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))] {a : α} {b : α}, Iff (LE.le.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 b)) (LE.le.{u2} α (Preorder.toHasLe.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))) a b)
 but is expected to have type
   forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} 𝕆] [_inst_3 : GradeOrder.{u2, u1} 𝕆 α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))] {a : α} {b : α}, Iff (LE.le.{u2} 𝕆 (Preorder.toLE.{u2} 𝕆 _inst_2) (grade.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2 _inst_3 a) (grade.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2 _inst_3 b)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)
 Case conversion may be inaccurate. Consider using '#align grade_le_grade_iff grade_le_grade_iffₓ'. -/
@@ -262,7 +262,7 @@ theorem grade_le_grade_iff : grade 𝕆 a ≤ grade 𝕆 b ↔ a ≤ b :=
 
 /- warning: grade_lt_grade_iff -> grade_lt_grade_iff is a dubious translation:
 lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))] {a : α} {b : α}, Iff (LT.lt.{u1} 𝕆 (Preorder.toLT.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 b)) (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))) a b)
+  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))] {a : α} {b : α}, Iff (LT.lt.{u1} 𝕆 (Preorder.toHasLt.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 b)) (LT.lt.{u2} α (Preorder.toHasLt.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))) a b)
 but is expected to have type
   forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} 𝕆] [_inst_3 : GradeOrder.{u2, u1} 𝕆 α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))] {a : α} {b : α}, Iff (LT.lt.{u2} 𝕆 (Preorder.toLT.{u2} 𝕆 _inst_2) (grade.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2 _inst_3 a) (grade.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2 _inst_3 b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)
 Case conversion may be inaccurate. Consider using '#align grade_lt_grade_iff grade_lt_grade_iffₓ'. -/
@@ -294,7 +294,7 @@ theorem grade_ne_grade_iff : grade 𝕆 a ≠ grade 𝕆 b ↔ a ≠ b :=
 
 /- warning: grade_covby_grade_iff -> grade_covby_grade_iff is a dubious translation:
 lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))] {a : α} {b : α}, Iff (Covby.{u1} 𝕆 (Preorder.toLT.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 b)) (Covby.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))) a b)
+  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : LinearOrder.{u2} α] [_inst_3 : GradeOrder.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))] {a : α} {b : α}, Iff (Covby.{u1} 𝕆 (Preorder.toHasLt.{u1} 𝕆 _inst_1) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 a) (grade.{u1, u2} 𝕆 α _inst_1 (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2)))) _inst_3 b)) (Covby.{u2} α (Preorder.toHasLt.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_2))))) a b)
 but is expected to have type
   forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} 𝕆] [_inst_3 : GradeOrder.{u2, u1} 𝕆 α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))] {a : α} {b : α}, Iff (Covby.{u2} 𝕆 (Preorder.toLT.{u2} 𝕆 _inst_2) (grade.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2 _inst_3 a) (grade.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2 _inst_3 b)) (Covby.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)
 Case conversion may be inaccurate. Consider using '#align grade_covby_grade_iff grade_covby_grade_iffₓ'. -/
@@ -314,7 +314,7 @@ variable [PartialOrder 𝕆] [Preorder α]
 
 /- warning: grade_bot -> grade_bot is a dubious translation:
 lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : PartialOrder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : OrderBot.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 (PartialOrder.toPreorder.{u1} 𝕆 _inst_1))] [_inst_4 : OrderBot.{u2} α (Preorder.toLE.{u2} α _inst_2)] [_inst_5 : GradeMinOrder.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2], Eq.{succ u1} 𝕆 (grade.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2 (GradeMinOrder.toGradeOrder.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2 _inst_5) (Bot.bot.{u2} α (OrderBot.toHasBot.{u2} α (Preorder.toLE.{u2} α _inst_2) _inst_4))) (Bot.bot.{u1} 𝕆 (OrderBot.toHasBot.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 (PartialOrder.toPreorder.{u1} 𝕆 _inst_1)) _inst_3))
+  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : PartialOrder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : OrderBot.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 (PartialOrder.toPreorder.{u1} 𝕆 _inst_1))] [_inst_4 : OrderBot.{u2} α (Preorder.toHasLe.{u2} α _inst_2)] [_inst_5 : GradeMinOrder.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2], Eq.{succ u1} 𝕆 (grade.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2 (GradeMinOrder.toGradeOrder.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2 _inst_5) (Bot.bot.{u2} α (OrderBot.toHasBot.{u2} α (Preorder.toHasLe.{u2} α _inst_2) _inst_4))) (Bot.bot.{u1} 𝕆 (OrderBot.toHasBot.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 (PartialOrder.toPreorder.{u1} 𝕆 _inst_1)) _inst_3))
 but is expected to have type
   forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : PartialOrder.{u2} 𝕆] [_inst_2 : Preorder.{u1} α] [_inst_3 : OrderBot.{u2} 𝕆 (Preorder.toLE.{u2} 𝕆 (PartialOrder.toPreorder.{u2} 𝕆 _inst_1))] [_inst_4 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_2)] [_inst_5 : GradeMinOrder.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u2} 𝕆 _inst_1) _inst_2], Eq.{succ u2} 𝕆 (grade.{u2, u1} 𝕆 α _inst_2 (PartialOrder.toPreorder.{u2} 𝕆 _inst_1) (GradeMinOrder.toGradeOrder.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u2} 𝕆 _inst_1) _inst_2 _inst_5) (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_2) _inst_4))) (Bot.bot.{u2} 𝕆 (OrderBot.toBot.{u2} 𝕆 (Preorder.toLE.{u2} 𝕆 (PartialOrder.toPreorder.{u2} 𝕆 _inst_1)) _inst_3))
 Case conversion may be inaccurate. Consider using '#align grade_bot grade_botₓ'. -/
@@ -325,7 +325,7 @@ theorem grade_bot [OrderBot 𝕆] [OrderBot α] [GradeMinOrder 𝕆 α] : grade
 
 /- warning: grade_top -> grade_top is a dubious translation:
 lean 3 declaration is
-  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : PartialOrder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : OrderTop.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 (PartialOrder.toPreorder.{u1} 𝕆 _inst_1))] [_inst_4 : OrderTop.{u2} α (Preorder.toLE.{u2} α _inst_2)] [_inst_5 : GradeMaxOrder.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2], Eq.{succ u1} 𝕆 (grade.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2 (GradeMaxOrder.toGradeOrder.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2 _inst_5) (Top.top.{u2} α (OrderTop.toHasTop.{u2} α (Preorder.toLE.{u2} α _inst_2) _inst_4))) (Top.top.{u1} 𝕆 (OrderTop.toHasTop.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 (PartialOrder.toPreorder.{u1} 𝕆 _inst_1)) _inst_3))
+  forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : PartialOrder.{u1} 𝕆] [_inst_2 : Preorder.{u2} α] [_inst_3 : OrderTop.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 (PartialOrder.toPreorder.{u1} 𝕆 _inst_1))] [_inst_4 : OrderTop.{u2} α (Preorder.toHasLe.{u2} α _inst_2)] [_inst_5 : GradeMaxOrder.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2], Eq.{succ u1} 𝕆 (grade.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2 (GradeMaxOrder.toGradeOrder.{u1, u2} 𝕆 α (PartialOrder.toPreorder.{u1} 𝕆 _inst_1) _inst_2 _inst_5) (Top.top.{u2} α (OrderTop.toHasTop.{u2} α (Preorder.toHasLe.{u2} α _inst_2) _inst_4))) (Top.top.{u1} 𝕆 (OrderTop.toHasTop.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 (PartialOrder.toPreorder.{u1} 𝕆 _inst_1)) _inst_3))
 but is expected to have type
   forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : PartialOrder.{u2} 𝕆] [_inst_2 : Preorder.{u1} α] [_inst_3 : OrderTop.{u2} 𝕆 (Preorder.toLE.{u2} 𝕆 (PartialOrder.toPreorder.{u2} 𝕆 _inst_1))] [_inst_4 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_2)] [_inst_5 : GradeMaxOrder.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u2} 𝕆 _inst_1) _inst_2], Eq.{succ u2} 𝕆 (grade.{u2, u1} 𝕆 α _inst_2 (PartialOrder.toPreorder.{u2} 𝕆 _inst_1) (GradeMaxOrder.toGradeOrder.{u2, u1} 𝕆 α (PartialOrder.toPreorder.{u2} 𝕆 _inst_1) _inst_2 _inst_5) (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_2) _inst_4))) (Top.top.{u2} 𝕆 (OrderTop.toTop.{u2} 𝕆 (Preorder.toLE.{u2} 𝕆 (PartialOrder.toPreorder.{u2} 𝕆 _inst_1)) _inst_3))
 Case conversion may be inaccurate. Consider using '#align grade_top grade_topₓ'. -/
@@ -402,7 +402,12 @@ theorem grade_ofDual [GradeOrder 𝕆 α] (a : αᵒᵈ) : grade 𝕆 (ofDual a)
 /-! #### Lifting a graded order -/
 
 
-#print GradeOrder.liftLeft /-
+/- warning: grade_order.lift_left -> GradeOrder.liftLeft is a dubious translation:
+lean 3 declaration is
+  forall {𝕆 : Type.{u1}} {ℙ : Type.{u2}} {α : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} ℙ] [_inst_3 : Preorder.{u3} α] [_inst_5 : GradeOrder.{u1, u3} 𝕆 α _inst_1 _inst_3] (f : 𝕆 -> ℙ), (StrictMono.{u1, u2} 𝕆 ℙ _inst_1 _inst_2 f) -> (forall (a : 𝕆) (b : 𝕆), (Covby.{u1} 𝕆 (Preorder.toHasLt.{u1} 𝕆 _inst_1) a b) -> (Covby.{u2} ℙ (Preorder.toHasLt.{u2} ℙ _inst_2) (f a) (f b))) -> (GradeOrder.{u2, u3} ℙ α _inst_2 _inst_3)
+but is expected to have type
+  forall {𝕆 : Type.{u1}} {ℙ : Type.{u2}} {α : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} ℙ] [_inst_3 : Preorder.{u3} α] [_inst_5 : GradeOrder.{u1, u3} 𝕆 α _inst_1 _inst_3] (f : 𝕆 -> ℙ), (StrictMono.{u1, u2} 𝕆 ℙ _inst_1 _inst_2 f) -> (forall (a : 𝕆) (b : 𝕆), (Covby.{u1} 𝕆 (Preorder.toLT.{u1} 𝕆 _inst_1) a b) -> (Covby.{u2} ℙ (Preorder.toLT.{u2} ℙ _inst_2) (f a) (f b))) -> (GradeOrder.{u2, u3} ℙ α _inst_2 _inst_3)
+Case conversion may be inaccurate. Consider using '#align grade_order.lift_left GradeOrder.liftLeftₓ'. -/
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -413,9 +418,13 @@ def GradeOrder.liftLeft [GradeOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono
   grade_strictMono := hf.comp grade_strictMono
   covby_grade a b h := hcovby _ _ <| h.grade _
 #align grade_order.lift_left GradeOrder.liftLeft
--/
 
-#print GradeMinOrder.liftLeft /-
+/- warning: grade_min_order.lift_left -> GradeMinOrder.liftLeft is a dubious translation:
+lean 3 declaration is
+  forall {𝕆 : Type.{u1}} {ℙ : Type.{u2}} {α : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} ℙ] [_inst_3 : Preorder.{u3} α] [_inst_5 : GradeMinOrder.{u1, u3} 𝕆 α _inst_1 _inst_3] (f : 𝕆 -> ℙ), (StrictMono.{u1, u2} 𝕆 ℙ _inst_1 _inst_2 f) -> (forall (a : 𝕆) (b : 𝕆), (Covby.{u1} 𝕆 (Preorder.toHasLt.{u1} 𝕆 _inst_1) a b) -> (Covby.{u2} ℙ (Preorder.toHasLt.{u2} ℙ _inst_2) (f a) (f b))) -> (forall (a : 𝕆), (IsMin.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) a) -> (IsMin.{u2} ℙ (Preorder.toHasLe.{u2} ℙ _inst_2) (f a))) -> (GradeMinOrder.{u2, u3} ℙ α _inst_2 _inst_3)
+but is expected to have type
+  forall {𝕆 : Type.{u1}} {ℙ : Type.{u2}} {α : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} ℙ] [_inst_3 : Preorder.{u3} α] [_inst_5 : GradeMinOrder.{u1, u3} 𝕆 α _inst_1 _inst_3] (f : 𝕆 -> ℙ), (StrictMono.{u1, u2} 𝕆 ℙ _inst_1 _inst_2 f) -> (forall (a : 𝕆) (b : 𝕆), (Covby.{u1} 𝕆 (Preorder.toLT.{u1} 𝕆 _inst_1) a b) -> (Covby.{u2} ℙ (Preorder.toLT.{u2} ℙ _inst_2) (f a) (f b))) -> (forall (a : 𝕆), (IsMin.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_1) a) -> (IsMin.{u2} ℙ (Preorder.toLE.{u2} ℙ _inst_2) (f a))) -> (GradeMinOrder.{u2, u3} ℙ α _inst_2 _inst_3)
+Case conversion may be inaccurate. Consider using '#align grade_min_order.lift_left GradeMinOrder.liftLeftₓ'. -/
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -423,9 +432,13 @@ def GradeMinOrder.liftLeft [GradeMinOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : Stri
     (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a)) : GradeMinOrder ℙ α :=
   { GradeOrder.liftLeft f hf hcovby with isMin_grade := fun a ha => hmin _ <| ha.grade _ }
 #align grade_min_order.lift_left GradeMinOrder.liftLeft
--/
 
-#print GradeMaxOrder.liftLeft /-
+/- warning: grade_max_order.lift_left -> GradeMaxOrder.liftLeft is a dubious translation:
+lean 3 declaration is
+  forall {𝕆 : Type.{u1}} {ℙ : Type.{u2}} {α : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} ℙ] [_inst_3 : Preorder.{u3} α] [_inst_5 : GradeMaxOrder.{u1, u3} 𝕆 α _inst_1 _inst_3] (f : 𝕆 -> ℙ), (StrictMono.{u1, u2} 𝕆 ℙ _inst_1 _inst_2 f) -> (forall (a : 𝕆) (b : 𝕆), (Covby.{u1} 𝕆 (Preorder.toHasLt.{u1} 𝕆 _inst_1) a b) -> (Covby.{u2} ℙ (Preorder.toHasLt.{u2} ℙ _inst_2) (f a) (f b))) -> (forall (a : 𝕆), (IsMax.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) a) -> (IsMax.{u2} ℙ (Preorder.toHasLe.{u2} ℙ _inst_2) (f a))) -> (GradeMaxOrder.{u2, u3} ℙ α _inst_2 _inst_3)
+but is expected to have type
+  forall {𝕆 : Type.{u1}} {ℙ : Type.{u2}} {α : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} ℙ] [_inst_3 : Preorder.{u3} α] [_inst_5 : GradeMaxOrder.{u1, u3} 𝕆 α _inst_1 _inst_3] (f : 𝕆 -> ℙ), (StrictMono.{u1, u2} 𝕆 ℙ _inst_1 _inst_2 f) -> (forall (a : 𝕆) (b : 𝕆), (Covby.{u1} 𝕆 (Preorder.toLT.{u1} 𝕆 _inst_1) a b) -> (Covby.{u2} ℙ (Preorder.toLT.{u2} ℙ _inst_2) (f a) (f b))) -> (forall (a : 𝕆), (IsMax.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_1) a) -> (IsMax.{u2} ℙ (Preorder.toLE.{u2} ℙ _inst_2) (f a))) -> (GradeMaxOrder.{u2, u3} ℙ α _inst_2 _inst_3)
+Case conversion may be inaccurate. Consider using '#align grade_max_order.lift_left GradeMaxOrder.liftLeftₓ'. -/
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -433,9 +446,13 @@ def GradeMaxOrder.liftLeft [GradeMaxOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : Stri
     (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeMaxOrder ℙ α :=
   { GradeOrder.liftLeft f hf hcovby with isMax_grade := fun a ha => hmax _ <| ha.grade _ }
 #align grade_max_order.lift_left GradeMaxOrder.liftLeft
--/
 
-#print GradeBoundedOrder.liftLeft /-
+/- warning: grade_bounded_order.lift_left -> GradeBoundedOrder.liftLeft is a dubious translation:
+lean 3 declaration is
+  forall {𝕆 : Type.{u1}} {ℙ : Type.{u2}} {α : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} ℙ] [_inst_3 : Preorder.{u3} α] [_inst_5 : GradeBoundedOrder.{u1, u3} 𝕆 α _inst_1 _inst_3] (f : 𝕆 -> ℙ), (StrictMono.{u1, u2} 𝕆 ℙ _inst_1 _inst_2 f) -> (forall (a : 𝕆) (b : 𝕆), (Covby.{u1} 𝕆 (Preorder.toHasLt.{u1} 𝕆 _inst_1) a b) -> (Covby.{u2} ℙ (Preorder.toHasLt.{u2} ℙ _inst_2) (f a) (f b))) -> (forall (a : 𝕆), (IsMin.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) a) -> (IsMin.{u2} ℙ (Preorder.toHasLe.{u2} ℙ _inst_2) (f a))) -> (forall (a : 𝕆), (IsMax.{u1} 𝕆 (Preorder.toHasLe.{u1} 𝕆 _inst_1) a) -> (IsMax.{u2} ℙ (Preorder.toHasLe.{u2} ℙ _inst_2) (f a))) -> (GradeBoundedOrder.{u2, u3} ℙ α _inst_2 _inst_3)
+but is expected to have type
+  forall {𝕆 : Type.{u1}} {ℙ : Type.{u2}} {α : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_2 : Preorder.{u2} ℙ] [_inst_3 : Preorder.{u3} α] [_inst_5 : GradeBoundedOrder.{u1, u3} 𝕆 α _inst_1 _inst_3] (f : 𝕆 -> ℙ), (StrictMono.{u1, u2} 𝕆 ℙ _inst_1 _inst_2 f) -> (forall (a : 𝕆) (b : 𝕆), (Covby.{u1} 𝕆 (Preorder.toLT.{u1} 𝕆 _inst_1) a b) -> (Covby.{u2} ℙ (Preorder.toLT.{u2} ℙ _inst_2) (f a) (f b))) -> (forall (a : 𝕆), (IsMin.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_1) a) -> (IsMin.{u2} ℙ (Preorder.toLE.{u2} ℙ _inst_2) (f a))) -> (forall (a : 𝕆), (IsMax.{u1} 𝕆 (Preorder.toLE.{u1} 𝕆 _inst_1) a) -> (IsMax.{u2} ℙ (Preorder.toLE.{u2} ℙ _inst_2) (f a))) -> (GradeBoundedOrder.{u2, u3} ℙ α _inst_2 _inst_3)
+Case conversion may be inaccurate. Consider using '#align grade_bounded_order.lift_left GradeBoundedOrder.liftLeftₓ'. -/
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -444,9 +461,13 @@ def GradeBoundedOrder.liftLeft [GradeBoundedOrder 𝕆 α] (f : 𝕆 → ℙ) (h
     (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeBoundedOrder ℙ α :=
   { GradeMinOrder.liftLeft f hf hcovby hmin, GradeMaxOrder.liftLeft f hf hcovby hmax with }
 #align grade_bounded_order.lift_left GradeBoundedOrder.liftLeft
--/
 
-#print GradeOrder.liftRight /-
+/- warning: grade_order.lift_right -> GradeOrder.liftRight is a dubious translation:
+lean 3 declaration is
+  forall {𝕆 : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_4 : Preorder.{u3} β] [_inst_5 : GradeOrder.{u1, u3} 𝕆 β _inst_1 _inst_4] (f : α -> β), (StrictMono.{u2, u3} α β _inst_3 _inst_4 f) -> (forall (a : α) (b : α), (Covby.{u2} α (Preorder.toHasLt.{u2} α _inst_3) a b) -> (Covby.{u3} β (Preorder.toHasLt.{u3} β _inst_4) (f a) (f b))) -> (GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_3)
+but is expected to have type
+  forall {𝕆 : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_4 : Preorder.{u3} β] [_inst_5 : GradeOrder.{u1, u3} 𝕆 β _inst_1 _inst_4] (f : α -> β), (StrictMono.{u2, u3} α β _inst_3 _inst_4 f) -> (forall (a : α) (b : α), (Covby.{u2} α (Preorder.toLT.{u2} α _inst_3) a b) -> (Covby.{u3} β (Preorder.toLT.{u3} β _inst_4) (f a) (f b))) -> (GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_3)
+Case conversion may be inaccurate. Consider using '#align grade_order.lift_right GradeOrder.liftRightₓ'. -/
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -457,9 +478,13 @@ def GradeOrder.liftRight [GradeOrder 𝕆 β] (f : α → β) (hf : StrictMono f
   grade_strictMono := grade_strictMono.comp hf
   covby_grade a b h := (hcovby _ _ h).grade _
 #align grade_order.lift_right GradeOrder.liftRight
--/
 
-#print GradeMinOrder.liftRight /-
+/- warning: grade_min_order.lift_right -> GradeMinOrder.liftRight is a dubious translation:
+lean 3 declaration is
+  forall {𝕆 : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_4 : Preorder.{u3} β] [_inst_5 : GradeMinOrder.{u1, u3} 𝕆 β _inst_1 _inst_4] (f : α -> β), (StrictMono.{u2, u3} α β _inst_3 _inst_4 f) -> (forall (a : α) (b : α), (Covby.{u2} α (Preorder.toHasLt.{u2} α _inst_3) a b) -> (Covby.{u3} β (Preorder.toHasLt.{u3} β _inst_4) (f a) (f b))) -> (forall (a : α), (IsMin.{u2} α (Preorder.toHasLe.{u2} α _inst_3) a) -> (IsMin.{u3} β (Preorder.toHasLe.{u3} β _inst_4) (f a))) -> (GradeMinOrder.{u1, u2} 𝕆 α _inst_1 _inst_3)
+but is expected to have type
+  forall {𝕆 : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_4 : Preorder.{u3} β] [_inst_5 : GradeMinOrder.{u1, u3} 𝕆 β _inst_1 _inst_4] (f : α -> β), (StrictMono.{u2, u3} α β _inst_3 _inst_4 f) -> (forall (a : α) (b : α), (Covby.{u2} α (Preorder.toLT.{u2} α _inst_3) a b) -> (Covby.{u3} β (Preorder.toLT.{u3} β _inst_4) (f a) (f b))) -> (forall (a : α), (IsMin.{u2} α (Preorder.toLE.{u2} α _inst_3) a) -> (IsMin.{u3} β (Preorder.toLE.{u3} β _inst_4) (f a))) -> (GradeMinOrder.{u1, u2} 𝕆 α _inst_1 _inst_3)
+Case conversion may be inaccurate. Consider using '#align grade_min_order.lift_right GradeMinOrder.liftRightₓ'. -/
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -467,9 +492,13 @@ def GradeMinOrder.liftRight [GradeMinOrder 𝕆 β] (f : α → β) (hf : Strict
     (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a)) : GradeMinOrder 𝕆 α :=
   { GradeOrder.liftRight f hf hcovby with isMin_grade := fun a ha => (hmin _ ha).grade _ }
 #align grade_min_order.lift_right GradeMinOrder.liftRight
--/
 
-#print GradeMaxOrder.liftRight /-
+/- warning: grade_max_order.lift_right -> GradeMaxOrder.liftRight is a dubious translation:
+lean 3 declaration is
+  forall {𝕆 : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_4 : Preorder.{u3} β] [_inst_5 : GradeMaxOrder.{u1, u3} 𝕆 β _inst_1 _inst_4] (f : α -> β), (StrictMono.{u2, u3} α β _inst_3 _inst_4 f) -> (forall (a : α) (b : α), (Covby.{u2} α (Preorder.toHasLt.{u2} α _inst_3) a b) -> (Covby.{u3} β (Preorder.toHasLt.{u3} β _inst_4) (f a) (f b))) -> (forall (a : α), (IsMax.{u2} α (Preorder.toHasLe.{u2} α _inst_3) a) -> (IsMax.{u3} β (Preorder.toHasLe.{u3} β _inst_4) (f a))) -> (GradeMaxOrder.{u1, u2} 𝕆 α _inst_1 _inst_3)
+but is expected to have type
+  forall {𝕆 : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_4 : Preorder.{u3} β] [_inst_5 : GradeMaxOrder.{u1, u3} 𝕆 β _inst_1 _inst_4] (f : α -> β), (StrictMono.{u2, u3} α β _inst_3 _inst_4 f) -> (forall (a : α) (b : α), (Covby.{u2} α (Preorder.toLT.{u2} α _inst_3) a b) -> (Covby.{u3} β (Preorder.toLT.{u3} β _inst_4) (f a) (f b))) -> (forall (a : α), (IsMax.{u2} α (Preorder.toLE.{u2} α _inst_3) a) -> (IsMax.{u3} β (Preorder.toLE.{u3} β _inst_4) (f a))) -> (GradeMaxOrder.{u1, u2} 𝕆 α _inst_1 _inst_3)
+Case conversion may be inaccurate. Consider using '#align grade_max_order.lift_right GradeMaxOrder.liftRightₓ'. -/
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -477,9 +506,13 @@ def GradeMaxOrder.liftRight [GradeMaxOrder 𝕆 β] (f : α → β) (hf : Strict
     (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeMaxOrder 𝕆 α :=
   { GradeOrder.liftRight f hf hcovby with isMax_grade := fun a ha => (hmax _ ha).grade _ }
 #align grade_max_order.lift_right GradeMaxOrder.liftRight
--/
 
-#print GradeBoundedOrder.liftRight /-
+/- warning: grade_bounded_order.lift_right -> GradeBoundedOrder.liftRight is a dubious translation:
+lean 3 declaration is
+  forall {𝕆 : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_4 : Preorder.{u3} β] [_inst_5 : GradeBoundedOrder.{u1, u3} 𝕆 β _inst_1 _inst_4] (f : α -> β), (StrictMono.{u2, u3} α β _inst_3 _inst_4 f) -> (forall (a : α) (b : α), (Covby.{u2} α (Preorder.toHasLt.{u2} α _inst_3) a b) -> (Covby.{u3} β (Preorder.toHasLt.{u3} β _inst_4) (f a) (f b))) -> (forall (a : α), (IsMin.{u2} α (Preorder.toHasLe.{u2} α _inst_3) a) -> (IsMin.{u3} β (Preorder.toHasLe.{u3} β _inst_4) (f a))) -> (forall (a : α), (IsMax.{u2} α (Preorder.toHasLe.{u2} α _inst_3) a) -> (IsMax.{u3} β (Preorder.toHasLe.{u3} β _inst_4) (f a))) -> (GradeBoundedOrder.{u1, u2} 𝕆 α _inst_1 _inst_3)
+but is expected to have type
+  forall {𝕆 : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_4 : Preorder.{u3} β] [_inst_5 : GradeBoundedOrder.{u1, u3} 𝕆 β _inst_1 _inst_4] (f : α -> β), (StrictMono.{u2, u3} α β _inst_3 _inst_4 f) -> (forall (a : α) (b : α), (Covby.{u2} α (Preorder.toLT.{u2} α _inst_3) a b) -> (Covby.{u3} β (Preorder.toLT.{u3} β _inst_4) (f a) (f b))) -> (forall (a : α), (IsMin.{u2} α (Preorder.toLE.{u2} α _inst_3) a) -> (IsMin.{u3} β (Preorder.toLE.{u3} β _inst_4) (f a))) -> (forall (a : α), (IsMax.{u2} α (Preorder.toLE.{u2} α _inst_3) a) -> (IsMax.{u3} β (Preorder.toLE.{u3} β _inst_4) (f a))) -> (GradeBoundedOrder.{u1, u2} 𝕆 α _inst_1 _inst_3)
+Case conversion may be inaccurate. Consider using '#align grade_bounded_order.lift_right GradeBoundedOrder.liftRightₓ'. -/
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
@@ -488,7 +521,6 @@ def GradeBoundedOrder.liftRight [GradeBoundedOrder 𝕆 β] (f : α → β) (hf
     (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeBoundedOrder 𝕆 α :=
   { GradeMinOrder.liftRight f hf hcovby hmin, GradeMaxOrder.liftRight f hf hcovby hmax with }
 #align grade_bounded_order.lift_right GradeBoundedOrder.liftRight
--/
 
 /-! #### `fin n`-graded to `ℕ`-graded to `ℤ`-graded -/
 

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

@@ -381,7 +381,7 @@ instance [GradeBoundedOrder 𝕆 α] : GradeBoundedOrder 𝕆ᵒᵈ αᵒᵈ :=
 lean 3 declaration is
   forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_5 : GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_3] (a : α), Eq.{succ u1} (OrderDual.{u1} 𝕆) (grade.{u1, u2} (OrderDual.{u1} 𝕆) (OrderDual.{u2} α) (OrderDual.preorder.{u1} 𝕆 _inst_1) (OrderDual.preorder.{u2} α _inst_3) (OrderDual.gradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_3 _inst_5) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} α (OrderDual.{u2} α)) (fun (_x : Equiv.{succ u2, succ u2} α (OrderDual.{u2} α)) => α -> (OrderDual.{u2} α)) (Equiv.hasCoeToFun.{succ u2, succ u2} α (OrderDual.{u2} α)) (OrderDual.toDual.{u2} α) a)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} 𝕆 (OrderDual.{u1} 𝕆)) (fun (_x : Equiv.{succ u1, succ u1} 𝕆 (OrderDual.{u1} 𝕆)) => 𝕆 -> (OrderDual.{u1} 𝕆)) (Equiv.hasCoeToFun.{succ u1, succ u1} 𝕆 (OrderDual.{u1} 𝕆)) (OrderDual.toDual.{u1} 𝕆) (grade.{u1, u2} 𝕆 α _inst_1 _inst_3 _inst_5 a))
 but is expected to have type
-  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : Preorder.{u2} 𝕆] [_inst_3 : Preorder.{u1} α] [_inst_5 : GradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3] (a : α), Eq.{succ u2} (OrderDual.{u2} 𝕆) (grade.{u2, u1} (OrderDual.{u2} 𝕆) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => OrderDual.{u1} α) a) (OrderDual.preorder.{u1} α _inst_3) (OrderDual.preorder.{u2} 𝕆 _inst_1) (OrderDual.gradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3 _inst_5) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} 𝕆 (OrderDual.{u2} 𝕆)) 𝕆 (fun (_x : 𝕆) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : 𝕆) => OrderDual.{u2} 𝕆) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} 𝕆 (OrderDual.{u2} 𝕆)) (OrderDual.toDual.{u2} 𝕆) (grade.{u2, u1} 𝕆 α _inst_3 _inst_1 _inst_5 a))
+  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : Preorder.{u2} 𝕆] [_inst_3 : Preorder.{u1} α] [_inst_5 : GradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3] (a : α), Eq.{succ u2} (OrderDual.{u2} 𝕆) (grade.{u2, u1} (OrderDual.{u2} 𝕆) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u1} α) a) (OrderDual.preorder.{u1} α _inst_3) (OrderDual.preorder.{u2} 𝕆 _inst_1) (OrderDual.gradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3 _inst_5) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} 𝕆 (OrderDual.{u2} 𝕆)) 𝕆 (fun (_x : 𝕆) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : 𝕆) => OrderDual.{u2} 𝕆) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} 𝕆 (OrderDual.{u2} 𝕆)) (OrderDual.toDual.{u2} 𝕆) (grade.{u2, u1} 𝕆 α _inst_3 _inst_1 _inst_5 a))
 Case conversion may be inaccurate. Consider using '#align grade_to_dual grade_toDualₓ'. -/
 @[simp]
 theorem grade_toDual [GradeOrder 𝕆 α] (a : α) : grade 𝕆ᵒᵈ (toDual a) = toDual (grade 𝕆 a) :=
@@ -392,7 +392,7 @@ theorem grade_toDual [GradeOrder 𝕆 α] (a : α) : grade 𝕆ᵒᵈ (toDual a)
 lean 3 declaration is
   forall {𝕆 : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} 𝕆] [_inst_3 : Preorder.{u2} α] [_inst_5 : GradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_3] (a : OrderDual.{u2} α), Eq.{succ u1} 𝕆 (grade.{u1, u2} 𝕆 α _inst_1 _inst_3 _inst_5 (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (fun (_x : Equiv.{succ u2, succ u2} (OrderDual.{u2} α) α) => (OrderDual.{u2} α) -> α) (Equiv.hasCoeToFun.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.ofDual.{u2} α) a)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} 𝕆) 𝕆) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} 𝕆) 𝕆) => (OrderDual.{u1} 𝕆) -> 𝕆) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} 𝕆) 𝕆) (OrderDual.ofDual.{u1} 𝕆) (grade.{u1, u2} (OrderDual.{u1} 𝕆) (OrderDual.{u2} α) (OrderDual.preorder.{u1} 𝕆 _inst_1) (OrderDual.preorder.{u2} α _inst_3) (OrderDual.gradeOrder.{u1, u2} 𝕆 α _inst_1 _inst_3 _inst_5) a))
 but is expected to have type
-  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : Preorder.{u2} 𝕆] [_inst_3 : Preorder.{u1} α] [_inst_5 : GradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3] (a : OrderDual.{u1} α), Eq.{succ u2} 𝕆 (grade.{u2, u1} 𝕆 ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} α) => α) a) _inst_3 _inst_1 _inst_5 (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} 𝕆) 𝕆) (OrderDual.{u2} 𝕆) (fun (_x : OrderDual.{u2} 𝕆) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u2} 𝕆) => 𝕆) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (OrderDual.{u2} 𝕆) 𝕆) (OrderDual.ofDual.{u2} 𝕆) (grade.{u2, u1} (OrderDual.{u2} 𝕆) (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_3) (OrderDual.preorder.{u2} 𝕆 _inst_1) (OrderDual.gradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3 _inst_5) a))
+  forall {𝕆 : Type.{u2}} {α : Type.{u1}} [_inst_1 : Preorder.{u2} 𝕆] [_inst_3 : Preorder.{u1} α] [_inst_5 : GradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3] (a : OrderDual.{u1} α), Eq.{succ u2} 𝕆 (grade.{u2, u1} 𝕆 ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} α) => α) a) _inst_3 _inst_1 _inst_5 (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} 𝕆) 𝕆) (OrderDual.{u2} 𝕆) (fun (_x : OrderDual.{u2} 𝕆) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u2} 𝕆) => 𝕆) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (OrderDual.{u2} 𝕆) 𝕆) (OrderDual.ofDual.{u2} 𝕆) (grade.{u2, u1} (OrderDual.{u2} 𝕆) (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_3) (OrderDual.preorder.{u2} 𝕆 _inst_1) (OrderDual.gradeOrder.{u2, u1} 𝕆 α _inst_1 _inst_3 _inst_5) a))
 Case conversion may be inaccurate. Consider using '#align grade_of_dual grade_ofDualₓ'. -/
 @[simp]
 theorem grade_ofDual [GradeOrder 𝕆 α] (a : αᵒᵈ) : grade 𝕆 (ofDual a) = ofDual (grade 𝕆ᵒᵈ a) :=

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

In #10496, a better fix was suggested in the comments by @Ruben-VandeVelde: make GradedOrder.grade protected to freely use grade for _root_.grade. This implements that fix.

@@ -63,7 +63,7 @@ variable {𝕆 ℙ α β : Type*}
 `grade 𝕆 : α → 𝕆` which preserves order covering (`CovBy`). -/
 class GradeOrder (𝕆 α : Type*) [Preorder 𝕆] [Preorder α] where
   /-- The grading function. -/
-  grade : α → 𝕆
+  protected grade : α → 𝕆
   /-- `grade` is strictly monotonic. -/
   grade_strictMono : StrictMono grade
   /-- `grade` preserves `CovBy`. -/
@@ -266,7 +266,7 @@ theorem grade_ofDual [GradeOrder 𝕆 α] (a : αᵒᵈ) : grade 𝕆 (ofDual a)
 @[reducible]
 def GradeOrder.liftLeft [GradeOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono f)
     (hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) : GradeOrder ℙ α where
-  grade := f ∘ _root_.grade 𝕆
+  grade := f ∘ grade 𝕆
   grade_strictMono := hf.comp grade_strictMono
   covBy_grade _ _ h := hcovBy _ _ <| h.grade _
 #align grade_order.lift_left GradeOrder.liftLeft
@@ -301,7 +301,7 @@ def GradeBoundedOrder.liftLeft [GradeBoundedOrder 𝕆 α] (f : 𝕆 → ℙ) (h
 @[reducible]
 def GradeOrder.liftRight [GradeOrder 𝕆 β] (f : α → β) (hf : StrictMono f)
     (hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) : GradeOrder 𝕆 α where
-  grade := _root_.grade 𝕆 ∘ f
+  grade := grade 𝕆 ∘ f
   grade_strictMono := grade_strictMono.comp hf
   covBy_grade _ _ h := (hcovBy _ _ h).grade _
 #align grade_order.lift_right GradeOrder.liftRight

Simple changes to remove porting notes.

@@ -89,14 +89,14 @@ class GradeBoundedOrder (𝕆 α : Type*) [Preorder 𝕆] [Preorder α] extends
 #align grade_bounded_order GradeBoundedOrder
 
 section Preorder -- grading
--- PORTING NOTE: this `variable [Preorder 𝕆]` for the whole section seems to not work in Lean4
--- variable [Preorder 𝕆]
+variable [Preorder 𝕆]
 
 section Preorder -- graded order
 variable [Preorder α]
 
 section GradeOrder
-variable (𝕆) [Preorder 𝕆] [GradeOrder 𝕆 α] {a b : α}
+variable (𝕆)
+variable [GradeOrder 𝕆 α] {a b : α}
 
 /-- The grade of an element in a graded order. Morally, this is the number of elements you need to
 go down by to get to `⊥`. -/
@@ -265,9 +265,8 @@ theorem grade_ofDual [GradeOrder 𝕆 α] (a : αᵒᵈ) : grade 𝕆 (ofDual a)
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
 def GradeOrder.liftLeft [GradeOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono f)
-    (hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) : GradeOrder ℙ α
-    where
-  grade := f ∘ (@grade 𝕆 _ _ _ _) -- porting note - what the hell?! used to be `grade 𝕆`
+    (hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) : GradeOrder ℙ α where
+  grade := f ∘ _root_.grade 𝕆
   grade_strictMono := hf.comp grade_strictMono
   covBy_grade _ _ h := hcovBy _ _ <| h.grade _
 #align grade_order.lift_left GradeOrder.liftLeft
@@ -301,9 +300,8 @@ def GradeBoundedOrder.liftLeft [GradeBoundedOrder 𝕆 α] (f : 𝕆 → ℙ) (h
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
 def GradeOrder.liftRight [GradeOrder 𝕆 β] (f : α → β) (hf : StrictMono f)
-    (hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) : GradeOrder 𝕆 α
-    where
-  grade := (@grade 𝕆 _ _ _ _) ∘ f -- porting note: again, weird
+    (hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) : GradeOrder 𝕆 α where
+  grade := _root_.grade 𝕆 ∘ f
   grade_strictMono := grade_strictMono.comp hf
   covBy_grade _ _ h := (hcovBy _ _ h).grade _
 #align grade_order.lift_right GradeOrder.liftRight

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -3,7 +3,6 @@ Copyright (c) 2022 Yaël Dillies, Violeta Hernández Palacios. All rights reserv
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies, Violeta Hernández Palacios, Grayson Burton, Vladimir Ivanov
 -/
-import Mathlib.Data.Finset.Basic
 import Mathlib.Data.Int.SuccPred
 
 #align_import order.grade from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
@@ -56,7 +55,7 @@ Instead, we define graded orders by their grade function, without talking about
 * [Richard Stanley, *Enumerative Combinatorics*][stanley2012]
 -/
 
-open Finset Nat OrderDual
+open Nat OrderDual
 
 variable {𝕆 ℙ α β : Type*}
 

Rename

• Covby → CovBy, Wcovby → WCovBy
• *covby* → *covBy*
• wcovby.finset_val → WCovBy.finset_val, wcovby.finset_coe → WCovBy.finset_coe
• Covby.is_coatom → CovBy.isCoatom

@@ -61,14 +61,14 @@ open Finset Nat OrderDual
 variable {𝕆 ℙ α β : Type*}
 
 /-- An `𝕆`-graded order is an order `α` equipped with a strictly monotone function
-`grade 𝕆 : α → 𝕆` which preserves order covering (`Covby`). -/
+`grade 𝕆 : α → 𝕆` which preserves order covering (`CovBy`). -/
 class GradeOrder (𝕆 α : Type*) [Preorder 𝕆] [Preorder α] where
   /-- The grading function. -/
   grade : α → 𝕆
   /-- `grade` is strictly monotonic. -/
   grade_strictMono : StrictMono grade
-  /-- `grade` preserves `Covby`. -/
-  covby_grade ⦃a b : α⦄ : a ⋖ b → grade a ⋖ grade b
+  /-- `grade` preserves `CovBy`. -/
+  covBy_grade ⦃a b : α⦄ : a ⋖ b → grade a ⋖ grade b
 #align grade_order GradeOrder
 
 /-- An `𝕆`-graded order where minimal elements have minimal grades. -/
@@ -105,9 +105,9 @@ def grade : α → 𝕆 :=
   GradeOrder.grade
 #align grade grade
 
-protected theorem Covby.grade (h : a ⋖ b) : grade 𝕆 a ⋖ grade 𝕆 b :=
-  GradeOrder.covby_grade h
-#align covby.grade Covby.grade
+protected theorem CovBy.grade (h : a ⋖ b) : grade 𝕆 a ⋖ grade 𝕆 b :=
+  GradeOrder.covBy_grade h
+#align covby.grade CovBy.grade
 
 variable {𝕆}
 
@@ -115,10 +115,10 @@ theorem grade_strictMono : StrictMono (grade 𝕆 : α → 𝕆) :=
   GradeOrder.grade_strictMono
 #align grade_strict_mono grade_strictMono
 
-theorem covby_iff_lt_covby_grade : a ⋖ b ↔ a < b ∧ grade 𝕆 a ⋖ grade 𝕆 b :=
+theorem covBy_iff_lt_covBy_grade : a ⋖ b ↔ a < b ∧ grade 𝕆 a ⋖ grade 𝕆 b :=
   ⟨fun h => ⟨h.1, h.grade _⟩,
     And.imp_right fun h _ ha hb => h.2 (grade_strictMono ha) <| grade_strictMono hb⟩
-#align covby_iff_lt_covby_grade covby_iff_lt_covby_grade
+#align covby_iff_lt_covby_grade covBy_iff_lt_covBy_grade
 
 end GradeOrder
 
@@ -191,9 +191,9 @@ theorem grade_ne_grade_iff : grade 𝕆 a ≠ grade 𝕆 b ↔ a ≠ b :=
   grade_injective.ne_iff
 #align grade_ne_grade_iff grade_ne_grade_iff
 
-theorem grade_covby_grade_iff : grade 𝕆 a ⋖ grade 𝕆 b ↔ a ⋖ b :=
-  (covby_iff_lt_covby_grade.trans <| and_iff_right_of_imp fun h => grade_lt_grade_iff.1 h.1).symm
-#align grade_covby_grade_iff grade_covby_grade_iff
+theorem grade_covBy_grade_iff : grade 𝕆 a ⋖ grade 𝕆 b ↔ a ⋖ b :=
+  (covBy_iff_lt_covBy_grade.trans <| and_iff_right_of_imp fun h => grade_lt_grade_iff.1 h.1).symm
+#align grade_covby_grade_iff grade_covBy_grade_iff
 
 end LinearOrder
 
@@ -226,7 +226,7 @@ instance Preorder.toGradeBoundedOrder : GradeBoundedOrder α α where
   isMin_grade _ := id
   isMax_grade _ := id
   grade_strictMono := strictMono_id
-  covby_grade _ _ := id
+  covBy_grade _ _ := id
 #align preorder.to_grade_bounded_order Preorder.toGradeBoundedOrder
 
 @[simp]
@@ -239,7 +239,7 @@ theorem grade_self (a : α) : grade α a = a :=
 instance OrderDual.gradeOrder [GradeOrder 𝕆 α] : GradeOrder 𝕆ᵒᵈ αᵒᵈ where
   grade := toDual ∘ grade 𝕆 ∘ ofDual
   grade_strictMono := grade_strictMono.dual
-  covby_grade _ _ h := (h.ofDual.grade _).toDual
+  covBy_grade _ _ h := (h.ofDual.grade _).toDual
 
 instance OrderDual.gradeMinOrder [GradeMaxOrder 𝕆 α] : GradeMinOrder 𝕆ᵒᵈ αᵒᵈ :=
   { OrderDual.gradeOrder with isMin_grade := fun _ => IsMax.grade (α := α) 𝕆 }
@@ -266,72 +266,72 @@ theorem grade_ofDual [GradeOrder 𝕆 α] (a : αᵒᵈ) : grade 𝕆 (ofDual a)
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
 def GradeOrder.liftLeft [GradeOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono f)
-    (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) : GradeOrder ℙ α
+    (hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) : GradeOrder ℙ α
     where
   grade := f ∘ (@grade 𝕆 _ _ _ _) -- porting note - what the hell?! used to be `grade 𝕆`
   grade_strictMono := hf.comp grade_strictMono
-  covby_grade _ _ h := hcovby _ _ <| h.grade _
+  covBy_grade _ _ h := hcovBy _ _ <| h.grade _
 #align grade_order.lift_left GradeOrder.liftLeft
 
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
 def GradeMinOrder.liftLeft [GradeMinOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono f)
-    (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a)) : GradeMinOrder ℙ α :=
-  { GradeOrder.liftLeft f hf hcovby with isMin_grade := fun _ ha => hmin _ <| ha.grade _ }
+    (hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a)) : GradeMinOrder ℙ α :=
+  { GradeOrder.liftLeft f hf hcovBy with isMin_grade := fun _ ha => hmin _ <| ha.grade _ }
 #align grade_min_order.lift_left GradeMinOrder.liftLeft
 
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
 def GradeMaxOrder.liftLeft [GradeMaxOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono f)
-    (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeMaxOrder ℙ α :=
-  { GradeOrder.liftLeft f hf hcovby with isMax_grade := fun _ ha => hmax _ <| ha.grade _ }
+    (hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeMaxOrder ℙ α :=
+  { GradeOrder.liftLeft f hf hcovBy with isMax_grade := fun _ ha => hmax _ <| ha.grade _ }
 #align grade_max_order.lift_left GradeMaxOrder.liftLeft
 
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
 def GradeBoundedOrder.liftLeft [GradeBoundedOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono f)
-    (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a))
+    (hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a))
     (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeBoundedOrder ℙ α :=
-  { GradeMinOrder.liftLeft f hf hcovby hmin, GradeMaxOrder.liftLeft f hf hcovby hmax with }
+  { GradeMinOrder.liftLeft f hf hcovBy hmin, GradeMaxOrder.liftLeft f hf hcovBy hmax with }
 #align grade_bounded_order.lift_left GradeBoundedOrder.liftLeft
 
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
 def GradeOrder.liftRight [GradeOrder 𝕆 β] (f : α → β) (hf : StrictMono f)
-    (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) : GradeOrder 𝕆 α
+    (hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) : GradeOrder 𝕆 α
     where
   grade := (@grade 𝕆 _ _ _ _) ∘ f -- porting note: again, weird
   grade_strictMono := grade_strictMono.comp hf
-  covby_grade _ _ h := (hcovby _ _ h).grade _
+  covBy_grade _ _ h := (hcovBy _ _ h).grade _
 #align grade_order.lift_right GradeOrder.liftRight
 
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
 def GradeMinOrder.liftRight [GradeMinOrder 𝕆 β] (f : α → β) (hf : StrictMono f)
-    (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a)) : GradeMinOrder 𝕆 α :=
-  { GradeOrder.liftRight f hf hcovby with isMin_grade := fun _ ha => (hmin _ ha).grade _ }
+    (hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a)) : GradeMinOrder 𝕆 α :=
+  { GradeOrder.liftRight f hf hcovBy with isMin_grade := fun _ ha => (hmin _ ha).grade _ }
 #align grade_min_order.lift_right GradeMinOrder.liftRight
 
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
 def GradeMaxOrder.liftRight [GradeMaxOrder 𝕆 β] (f : α → β) (hf : StrictMono f)
-    (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeMaxOrder 𝕆 α :=
-  { GradeOrder.liftRight f hf hcovby with isMax_grade := fun _ ha => (hmax _ ha).grade _ }
+    (hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeMaxOrder 𝕆 α :=
+  { GradeOrder.liftRight f hf hcovBy with isMax_grade := fun _ ha => (hmax _ ha).grade _ }
 #align grade_max_order.lift_right GradeMaxOrder.liftRight
 
 -- See note [reducible non-instances]
 /-- Lifts a graded order along a strictly monotone function. -/
 @[reducible]
 def GradeBoundedOrder.liftRight [GradeBoundedOrder 𝕆 β] (f : α → β) (hf : StrictMono f)
-    (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a))
+    (hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a))
     (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeBoundedOrder 𝕆 α :=
-  { GradeMinOrder.liftRight f hf hcovby hmin, GradeMaxOrder.liftRight f hf hcovby hmax with }
+  { GradeMinOrder.liftRight f hf hcovBy hmin, GradeMaxOrder.liftRight f hf hcovBy hmax with }
 #align grade_bounded_order.lift_right GradeBoundedOrder.liftRight
 
 /-! #### `Fin n`-graded to `ℕ`-graded to `ℤ`-graded -/
@@ -342,7 +342,7 @@ def GradeBoundedOrder.liftRight [GradeBoundedOrder 𝕆 β] (f : α → β) (hf
 inferrable. -/
 @[reducible]
 def GradeOrder.finToNat (n : ℕ) [GradeOrder (Fin n) α] : GradeOrder ℕ α :=
-  (GradeOrder.liftLeft (_ : Fin n → ℕ) Fin.val_strictMono) fun _ _ => Covby.coe_fin
+  (GradeOrder.liftLeft (_ : Fin n → ℕ) Fin.val_strictMono) fun _ _ => CovBy.coe_fin
 #align grade_order.fin_to_nat GradeOrder.finToNat
 
 -- See note [reducible non-instances]
@@ -350,7 +350,7 @@ def GradeOrder.finToNat (n : ℕ) [GradeOrder (Fin n) α] : GradeOrder ℕ α :=
 inferrable. -/
 @[reducible]
 def GradeMinOrder.finToNat (n : ℕ) [GradeMinOrder (Fin n) α] : GradeMinOrder ℕ α :=
-  (GradeMinOrder.liftLeft (_ : Fin n → ℕ) Fin.val_strictMono fun _ _ => Covby.coe_fin) fun a h => by
+  (GradeMinOrder.liftLeft (_ : Fin n → ℕ) Fin.val_strictMono fun _ _ => CovBy.coe_fin) fun a h => by
     cases n
     · exact a.elim0
     rw [h.eq_bot, Fin.bot_eq_zero]
@@ -358,5 +358,5 @@ def GradeMinOrder.finToNat (n : ℕ) [GradeMinOrder (Fin n) α] : GradeMinOrder
 #align grade_min_order.fin_to_nat GradeMinOrder.finToNat
 
 instance GradeOrder.natToInt [GradeOrder ℕ α] : GradeOrder ℤ α :=
-  (GradeOrder.liftLeft _ Int.coe_nat_strictMono) fun _ _ => Covby.cast_int
+  (GradeOrder.liftLeft _ Int.coe_nat_strictMono) fun _ _ => CovBy.cast_int
 #align grade_order.nat_to_int GradeOrder.natToInt

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

This has nice performance benefits.

@@ -58,11 +58,11 @@ Instead, we define graded orders by their grade function, without talking about
 
 open Finset Nat OrderDual
 
-variable {𝕆 ℙ α β : Type _}
+variable {𝕆 ℙ α β : Type*}
 
 /-- An `𝕆`-graded order is an order `α` equipped with a strictly monotone function
 `grade 𝕆 : α → 𝕆` which preserves order covering (`Covby`). -/
-class GradeOrder (𝕆 α : Type _) [Preorder 𝕆] [Preorder α] where
+class GradeOrder (𝕆 α : Type*) [Preorder 𝕆] [Preorder α] where
   /-- The grading function. -/
   grade : α → 𝕆
   /-- `grade` is strictly monotonic. -/
@@ -72,20 +72,20 @@ class GradeOrder (𝕆 α : Type _) [Preorder 𝕆] [Preorder α] where
 #align grade_order GradeOrder
 
 /-- An `𝕆`-graded order where minimal elements have minimal grades. -/
-class GradeMinOrder (𝕆 α : Type _) [Preorder 𝕆] [Preorder α] extends GradeOrder 𝕆 α where
+class GradeMinOrder (𝕆 α : Type*) [Preorder 𝕆] [Preorder α] extends GradeOrder 𝕆 α where
   /-- Minimal elements have minimal grades. -/
   isMin_grade ⦃a : α⦄ : IsMin a → IsMin (grade a)
 #align grade_min_order GradeMinOrder
 
 /-- An `𝕆`-graded order where maximal elements have maximal grades. -/
-class GradeMaxOrder (𝕆 α : Type _) [Preorder 𝕆] [Preorder α] extends GradeOrder 𝕆 α where
+class GradeMaxOrder (𝕆 α : Type*) [Preorder 𝕆] [Preorder α] extends GradeOrder 𝕆 α where
   /-- Maximal elements have maximal grades. -/
   isMax_grade ⦃a : α⦄ : IsMax a → IsMax (grade a)
 #align grade_max_order GradeMaxOrder
 
 /-- An `𝕆`-graded order where minimal elements have minimal grades and maximal elements have maximal
 grades. -/
-class GradeBoundedOrder (𝕆 α : Type _) [Preorder 𝕆] [Preorder α] extends GradeMinOrder 𝕆 α,
+class GradeBoundedOrder (𝕆 α : Type*) [Preorder 𝕆] [Preorder α] extends GradeMinOrder 𝕆 α,
   GradeMaxOrder 𝕆 α
 #align grade_bounded_order GradeBoundedOrder
 

@@ -74,13 +74,13 @@ class GradeOrder (𝕆 α : Type _) [Preorder 𝕆] [Preorder α] where
 /-- An `𝕆`-graded order where minimal elements have minimal grades. -/
 class GradeMinOrder (𝕆 α : Type _) [Preorder 𝕆] [Preorder α] extends GradeOrder 𝕆 α where
   /-- Minimal elements have minimal grades. -/
-  is_min_grade ⦃a : α⦄ : IsMin a → IsMin (grade a)
+  isMin_grade ⦃a : α⦄ : IsMin a → IsMin (grade a)
 #align grade_min_order GradeMinOrder
 
 /-- An `𝕆`-graded order where maximal elements have maximal grades. -/
 class GradeMaxOrder (𝕆 α : Type _) [Preorder 𝕆] [Preorder α] extends GradeOrder 𝕆 α where
   /-- Maximal elements have maximal grades. -/
-  is_max_grade ⦃a : α⦄ : IsMax a → IsMax (grade a)
+  isMax_grade ⦃a : α⦄ : IsMax a → IsMax (grade a)
 #align grade_max_order GradeMaxOrder
 
 /-- An `𝕆`-graded order where minimal elements have minimal grades and maximal elements have maximal
@@ -127,7 +127,7 @@ section GradeMinOrder
 variable (𝕆) [Preorder 𝕆] [GradeMinOrder 𝕆 α] {a : α}
 
 protected theorem IsMin.grade (h : IsMin a) : IsMin (grade 𝕆 a) :=
-  GradeMinOrder.is_min_grade h
+  GradeMinOrder.isMin_grade h
 #align is_min.grade IsMin.grade
 
 variable {𝕆}
@@ -144,7 +144,7 @@ section GradeMaxOrder
 variable (𝕆) [Preorder 𝕆] [GradeMaxOrder 𝕆 α] {a : α}
 
 protected theorem IsMax.grade (h : IsMax a) : IsMax (grade 𝕆 a) :=
-  GradeMaxOrder.is_max_grade h
+  GradeMaxOrder.isMax_grade h
 #align is_max.grade IsMax.grade
 
 variable {𝕆}
@@ -221,11 +221,10 @@ end PartialOrder
 
 variable [Preorder 𝕆] [Preorder ℙ] [Preorder α] [Preorder β]
 
-instance Preorder.toGradeBoundedOrder : GradeBoundedOrder α α
-    where
+instance Preorder.toGradeBoundedOrder : GradeBoundedOrder α α where
   grade := id
-  is_min_grade _ := id
-  is_max_grade _ := id
+  isMin_grade _ := id
+  isMax_grade _ := id
   grade_strictMono := strictMono_id
   covby_grade _ _ := id
 #align preorder.to_grade_bounded_order Preorder.toGradeBoundedOrder
@@ -237,17 +236,16 @@ theorem grade_self (a : α) : grade α a = a :=
 
 /-! #### Dual -/
 
-instance OrderDual.gradeOrder [GradeOrder 𝕆 α] : GradeOrder 𝕆ᵒᵈ αᵒᵈ
-    where
+instance OrderDual.gradeOrder [GradeOrder 𝕆 α] : GradeOrder 𝕆ᵒᵈ αᵒᵈ where
   grade := toDual ∘ grade 𝕆 ∘ ofDual
   grade_strictMono := grade_strictMono.dual
   covby_grade _ _ h := (h.ofDual.grade _).toDual
 
 instance OrderDual.gradeMinOrder [GradeMaxOrder 𝕆 α] : GradeMinOrder 𝕆ᵒᵈ αᵒᵈ :=
-  { OrderDual.gradeOrder with is_min_grade := fun _ => IsMax.grade (α := α) 𝕆 }
+  { OrderDual.gradeOrder with isMin_grade := fun _ => IsMax.grade (α := α) 𝕆 }
 
 instance OrderDual.gradeMaxOrder [GradeMinOrder 𝕆 α] : GradeMaxOrder 𝕆ᵒᵈ αᵒᵈ :=
-  { OrderDual.gradeOrder with is_max_grade := fun _ => IsMin.grade (α := α) 𝕆 }
+  { OrderDual.gradeOrder with isMax_grade := fun _ => IsMin.grade (α := α) 𝕆 }
 
 instance [GradeBoundedOrder 𝕆 α] : GradeBoundedOrder 𝕆ᵒᵈ αᵒᵈ :=
   { OrderDual.gradeMinOrder, OrderDual.gradeMaxOrder with }
@@ -280,7 +278,7 @@ def GradeOrder.liftLeft [GradeOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono
 @[reducible]
 def GradeMinOrder.liftLeft [GradeMinOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono f)
     (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a)) : GradeMinOrder ℙ α :=
-  { GradeOrder.liftLeft f hf hcovby with is_min_grade := fun _ ha => hmin _ <| ha.grade _ }
+  { GradeOrder.liftLeft f hf hcovby with isMin_grade := fun _ ha => hmin _ <| ha.grade _ }
 #align grade_min_order.lift_left GradeMinOrder.liftLeft
 
 -- See note [reducible non-instances]
@@ -288,7 +286,7 @@ def GradeMinOrder.liftLeft [GradeMinOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : Stri
 @[reducible]
 def GradeMaxOrder.liftLeft [GradeMaxOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono f)
     (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeMaxOrder ℙ α :=
-  { GradeOrder.liftLeft f hf hcovby with is_max_grade := fun _ ha => hmax _ <| ha.grade _ }
+  { GradeOrder.liftLeft f hf hcovby with isMax_grade := fun _ ha => hmax _ <| ha.grade _ }
 #align grade_max_order.lift_left GradeMaxOrder.liftLeft
 
 -- See note [reducible non-instances]
@@ -316,7 +314,7 @@ def GradeOrder.liftRight [GradeOrder 𝕆 β] (f : α → β) (hf : StrictMono f
 @[reducible]
 def GradeMinOrder.liftRight [GradeMinOrder 𝕆 β] (f : α → β) (hf : StrictMono f)
     (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a)) : GradeMinOrder 𝕆 α :=
-  { GradeOrder.liftRight f hf hcovby with is_min_grade := fun _ ha => (hmin _ ha).grade _ }
+  { GradeOrder.liftRight f hf hcovby with isMin_grade := fun _ ha => (hmin _ ha).grade _ }
 #align grade_min_order.lift_right GradeMinOrder.liftRight
 
 -- See note [reducible non-instances]
@@ -324,7 +322,7 @@ def GradeMinOrder.liftRight [GradeMinOrder 𝕆 β] (f : α → β) (hf : Strict
 @[reducible]
 def GradeMaxOrder.liftRight [GradeMaxOrder 𝕆 β] (f : α → β) (hf : StrictMono f)
     (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeMaxOrder 𝕆 α :=
-  { GradeOrder.liftRight f hf hcovby with is_max_grade := fun _ ha => (hmax _ ha).grade _ }
+  { GradeOrder.liftRight f hf hcovby with isMax_grade := fun _ ha => (hmax _ ha).grade _ }
 #align grade_max_order.lift_right GradeMaxOrder.liftRight
 
 -- See note [reducible non-instances]

• depends on: #5966

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

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Yaël Dillies, Violeta Hernández Palacios. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies, Violeta Hernández Palacios, Grayson Burton, Vladimir Ivanov
-
-! This file was ported from Lean 3 source module order.grade
-! leanprover-community/mathlib commit 9003f28797c0664a49e4179487267c494477d853
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Finset.Basic
 import Mathlib.Data.Int.SuccPred
 
+#align_import order.grade from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
+
 /-!
 # Graded orders
 

@@ -16,7 +16,7 @@ import Mathlib.Data.Int.SuccPred
 
 This file defines graded orders, also known as ranked orders.
 
-A `𝕆`-graded order is an order `α` equipped with a distinguished "grade" function `α → 𝕆` which
+An `𝕆`-graded order is an order `α` equipped with a distinguished "grade" function `α → 𝕆` which
 should be understood as giving the "height" of the elements. Usual graded orders are `ℕ`-graded,
 cograded orders are `ℕᵒᵈ`-graded, but we can also grade by `ℤ`, and polytopes are naturally
 `Fin n`-graded.
@@ -74,19 +74,19 @@ class GradeOrder (𝕆 α : Type _) [Preorder 𝕆] [Preorder α] where
   covby_grade ⦃a b : α⦄ : a ⋖ b → grade a ⋖ grade b
 #align grade_order GradeOrder
 
-/-- A `𝕆`-graded order where minimal elements have minimal grades. -/
+/-- An `𝕆`-graded order where minimal elements have minimal grades. -/
 class GradeMinOrder (𝕆 α : Type _) [Preorder 𝕆] [Preorder α] extends GradeOrder 𝕆 α where
   /-- Minimal elements have minimal grades. -/
   is_min_grade ⦃a : α⦄ : IsMin a → IsMin (grade a)
 #align grade_min_order GradeMinOrder
 
-/-- A `𝕆`-graded order where maximal elements have maximal grades. -/
+/-- An `𝕆`-graded order where maximal elements have maximal grades. -/
 class GradeMaxOrder (𝕆 α : Type _) [Preorder 𝕆] [Preorder α] extends GradeOrder 𝕆 α where
   /-- Maximal elements have maximal grades. -/
   is_max_grade ⦃a : α⦄ : IsMax a → IsMax (grade a)
 #align grade_max_order GradeMaxOrder
 
-/-- A `𝕆`-graded order where minimal elements have minimal grades and maximal elements have maximal
+/-- An `𝕆`-graded order where minimal elements have minimal grades and maximal elements have maximal
 grades. -/
 class GradeBoundedOrder (𝕆 α : Type _) [Preorder 𝕆] [Preorder α] extends GradeMinOrder 𝕆 α,
   GradeMaxOrder 𝕆 α

• Run a non-interactive version of fix-comments.py on all files.
• Go through the diff and manually add/discard/edit chunks.

@@ -339,7 +339,7 @@ def GradeBoundedOrder.liftRight [GradeBoundedOrder 𝕆 β] (f : α → β) (hf
   { GradeMinOrder.liftRight f hf hcovby hmin, GradeMaxOrder.liftRight f hf hcovby hmax with }
 #align grade_bounded_order.lift_right GradeBoundedOrder.liftRight
 
-/-! #### `fin n`-graded to `ℕ`-graded to `ℤ`-graded -/
+/-! #### `Fin n`-graded to `ℕ`-graded to `ℤ`-graded -/
 
 
 -- See note [reducible non-instances]

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

@@ -355,8 +355,7 @@ def GradeOrder.finToNat (n : ℕ) [GradeOrder (Fin n) α] : GradeOrder ℕ α :=
 inferrable. -/
 @[reducible]
 def GradeMinOrder.finToNat (n : ℕ) [GradeMinOrder (Fin n) α] : GradeMinOrder ℕ α :=
-  (GradeMinOrder.liftLeft (_ : Fin n → ℕ) Fin.val_strictMono fun _ _ => Covby.coe_fin) fun a h =>
-    by
+  (GradeMinOrder.liftLeft (_ : Fin n → ℕ) Fin.val_strictMono fun _ _ => Covby.coe_fin) fun a h => by
     cases n
     · exact a.elim0
     rw [h.eq_bot, Fin.bot_eq_zero]

@@ -69,7 +69,7 @@ class GradeOrder (𝕆 α : Type _) [Preorder 𝕆] [Preorder α] where
   /-- The grading function. -/
   grade : α → 𝕆
   /-- `grade` is strictly monotonic. -/
-  grade_strict_mono : StrictMono grade
+  grade_strictMono : StrictMono grade
   /-- `grade` preserves `Covby`. -/
   covby_grade ⦃a b : α⦄ : a ⋖ b → grade a ⋖ grade b
 #align grade_order GradeOrder
@@ -114,13 +114,13 @@ protected theorem Covby.grade (h : a ⋖ b) : grade 𝕆 a ⋖ grade 𝕆 b :=
 
 variable {𝕆}
 
-theorem grade_strict_mono : StrictMono (grade 𝕆 : α → 𝕆) :=
-  GradeOrder.grade_strict_mono
-#align grade_strict_mono grade_strict_mono
+theorem grade_strictMono : StrictMono (grade 𝕆 : α → 𝕆) :=
+  GradeOrder.grade_strictMono
+#align grade_strict_mono grade_strictMono
 
 theorem covby_iff_lt_covby_grade : a ⋖ b ↔ a < b ∧ grade 𝕆 a ⋖ grade 𝕆 b :=
   ⟨fun h => ⟨h.1, h.grade _⟩,
-    And.imp_right fun h _ ha hb => h.2 (grade_strict_mono ha) <| grade_strict_mono hb⟩
+    And.imp_right fun h _ ha hb => h.2 (grade_strictMono ha) <| grade_strictMono hb⟩
 #align covby_iff_lt_covby_grade covby_iff_lt_covby_grade
 
 end GradeOrder
@@ -137,7 +137,7 @@ variable {𝕆}
 
 @[simp]
 theorem isMin_grade_iff : IsMin (grade 𝕆 a) ↔ IsMin a :=
-  ⟨grade_strict_mono.isMin_of_apply, IsMin.grade _⟩
+  ⟨grade_strictMono.isMin_of_apply, IsMin.grade _⟩
 #align is_min_grade_iff isMin_grade_iff
 
 end GradeMinOrder
@@ -154,7 +154,7 @@ variable {𝕆}
 
 @[simp]
 theorem isMax_grade_iff : IsMax (grade 𝕆 a) ↔ IsMax a :=
-  ⟨grade_strict_mono.isMax_of_apply, IsMax.grade _⟩
+  ⟨grade_strictMono.isMax_of_apply, IsMax.grade _⟩
 #align is_max_grade_iff isMax_grade_iff
 
 end GradeMaxOrder
@@ -163,7 +163,7 @@ end Preorder
 
 -- graded order
 theorem grade_mono [PartialOrder α] [Preorder 𝕆] [GradeOrder 𝕆 α] : Monotone (grade 𝕆 : α → 𝕆) :=
-  grade_strict_mono.monotone
+  grade_strictMono.monotone
 #align grade_mono grade_mono
 
 section LinearOrder
@@ -172,17 +172,17 @@ section LinearOrder
 variable [LinearOrder α] [Preorder 𝕆] [GradeOrder 𝕆 α] {a b : α}
 
 theorem grade_injective : Function.Injective (grade 𝕆 : α → 𝕆) :=
-  grade_strict_mono.injective
+  grade_strictMono.injective
 #align grade_injective grade_injective
 
 @[simp]
 theorem grade_le_grade_iff : grade 𝕆 a ≤ grade 𝕆 b ↔ a ≤ b :=
-  grade_strict_mono.le_iff_le
+  grade_strictMono.le_iff_le
 #align grade_le_grade_iff grade_le_grade_iff
 
 @[simp]
 theorem grade_lt_grade_iff : grade 𝕆 a < grade 𝕆 b ↔ a < b :=
-  grade_strict_mono.lt_iff_lt
+  grade_strictMono.lt_iff_lt
 #align grade_lt_grade_iff grade_lt_grade_iff
 
 @[simp]
@@ -229,7 +229,7 @@ instance Preorder.toGradeBoundedOrder : GradeBoundedOrder α α
   grade := id
   is_min_grade _ := id
   is_max_grade _ := id
-  grade_strict_mono := strictMono_id
+  grade_strictMono := strictMono_id
   covby_grade _ _ := id
 #align preorder.to_grade_bounded_order Preorder.toGradeBoundedOrder
 
@@ -243,7 +243,7 @@ theorem grade_self (a : α) : grade α a = a :=
 instance OrderDual.gradeOrder [GradeOrder 𝕆 α] : GradeOrder 𝕆ᵒᵈ αᵒᵈ
     where
   grade := toDual ∘ grade 𝕆 ∘ ofDual
-  grade_strict_mono := grade_strict_mono.dual
+  grade_strictMono := grade_strictMono.dual
   covby_grade _ _ h := (h.ofDual.grade _).toDual
 
 instance OrderDual.gradeMinOrder [GradeMaxOrder 𝕆 α] : GradeMinOrder 𝕆ᵒᵈ αᵒᵈ :=
@@ -274,7 +274,7 @@ def GradeOrder.liftLeft [GradeOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono
     (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) : GradeOrder ℙ α
     where
   grade := f ∘ (@grade 𝕆 _ _ _ _) -- porting note - what the hell?! used to be `grade 𝕆`
-  grade_strict_mono := hf.comp grade_strict_mono
+  grade_strictMono := hf.comp grade_strictMono
   covby_grade _ _ h := hcovby _ _ <| h.grade _
 #align grade_order.lift_left GradeOrder.liftLeft
 
@@ -310,7 +310,7 @@ def GradeOrder.liftRight [GradeOrder 𝕆 β] (f : α → β) (hf : StrictMono f
     (hcovby : ∀ a b, a ⋖ b → f a ⋖ f b) : GradeOrder 𝕆 α
     where
   grade := (@grade 𝕆 _ _ _ _) ∘ f -- porting note: again, weird
-  grade_strict_mono := grade_strict_mono.comp hf
+  grade_strictMono := grade_strictMono.comp hf
   covby_grade _ _ h := (hcovby _ _ h).grade _
 #align grade_order.lift_right GradeOrder.liftRight
 

Some of the docs seem dodgy, even Lean3 wise. I left them as-is for now awaiting further input. I got some weird breakage with OrderDual that I don't know how to fix; judicious @ didn't seem to help. Also, some nice variable features seem to not be working in Lean4; they were very useful for organisation.

Co-authored-by: Kevin Buzzard <k.buzzard@imperial.ac.uk> Co-authored-by: Eric Rodriguez <37984851+ericrbg@users.noreply.github.com>