category_theory.category.preorder ⟷ Mathlib.CategoryTheory.Category.Preorder

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

@@ -3,8 +3,8 @@ Copyright (c) 2017 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Stephen Morgan, Scott Morrison, Johannes Hölzl, Reid Barton
 -/
-import Mathbin.CategoryTheory.Equivalence
-import Mathbin.Order.Hom.Basic
+import CategoryTheory.Equivalence
+import Order.Hom.Basic
 
 #align_import category_theory.category.preorder from "leanprover-community/mathlib"@"e97cf15cd1aec9bd5c193b2ffac5a6dc9118912b"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

@@ -71,7 +71,7 @@ def homOfLE {x y : X} (h : x ≤ y) : x ⟶ y :=
 #align category_theory.hom_of_le CategoryTheory.homOfLE
 -/
 
-alias hom_of_le ← _root_.has_le.le.hom
+alias _root_.has_le.le.hom := hom_of_le
 #align has_le.le.hom LE.le.hom
 
 #print CategoryTheory.homOfLE_refl /-
@@ -96,7 +96,7 @@ theorem leOfHom {x y : X} (h : x ⟶ y) : x ≤ y :=
 #align category_theory.le_of_hom CategoryTheory.leOfHom
 -/
 
-alias le_of_hom ← _root_.quiver.hom.le
+alias _root_.quiver.hom.le := le_of_hom
 #align quiver.hom.le Quiver.Hom.le
 
 #print CategoryTheory.leOfHom_homOfLE /-

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

@@ -2,15 +2,12 @@
 Copyright (c) 2017 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Stephen Morgan, Scott Morrison, Johannes Hölzl, Reid Barton
-
-! This file was ported from Lean 3 source module category_theory.category.preorder
-! leanprover-community/mathlib commit e97cf15cd1aec9bd5c193b2ffac5a6dc9118912b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.CategoryTheory.Equivalence
 import Mathbin.Order.Hom.Basic
 
+#align_import category_theory.category.preorder from "leanprover-community/mathlib"@"e97cf15cd1aec9bd5c193b2ffac5a6dc9118912b"
+
 /-!
 
 # Preorders as categories

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

@@ -128,11 +128,15 @@ theorem le_of_op_hom {x y : Xᵒᵖ} (h : x ⟶ y) : unop y ≤ unop x :=
 #align category_theory.le_of_op_hom CategoryTheory.le_of_op_hom
 -/
 
+#print CategoryTheory.uniqueToTop /-
 instance uniqueToTop [OrderTop X] {x : X} : Unique (x ⟶ ⊤) := by tidy
 #align category_theory.unique_to_top CategoryTheory.uniqueToTop
+-/
 
+#print CategoryTheory.uniqueFromBot /-
 instance uniqueFromBot [OrderBot X] {x : X} : Unique (⊥ ⟶ x) := by tidy
 #align category_theory.unique_from_bot CategoryTheory.uniqueFromBot
+-/
 
 end CategoryTheory
 
@@ -150,10 +154,12 @@ def Monotone.functor {f : X → Y} (h : Monotone f) : X ⥤ Y
 #align monotone.functor Monotone.functor
 -/
 
+#print Monotone.functor_obj /-
 @[simp]
 theorem Monotone.functor_obj {f : X → Y} (h : Monotone f) : h.Functor.obj = f :=
   rfl
 #align monotone.functor_obj Monotone.functor_obj
+-/
 
 end
 
@@ -163,11 +169,13 @@ section Preorder
 
 variable {X : Type u} {Y : Type v} [Preorder X] [Preorder Y]
 
+#print CategoryTheory.Functor.monotone /-
 /-- A functor between preorder categories is monotone.
 -/
 @[mono]
 theorem Functor.monotone (f : X ⥤ Y) : Monotone f.obj := fun x y hxy => (f.map hxy.Hom).le
 #align category_theory.functor.monotone CategoryTheory.Functor.monotone
+-/
 
 end Preorder
 
@@ -181,6 +189,7 @@ theorem Iso.to_eq {x y : X} (f : x ≅ y) : x = y :=
 #align category_theory.iso.to_eq CategoryTheory.Iso.to_eq
 -/
 
+#print CategoryTheory.Equivalence.toOrderIso /-
 /-- A categorical equivalence between partial orders is just an order isomorphism.
 -/
 def Equivalence.toOrderIso (e : X ≌ Y) : X ≃o Y
@@ -194,19 +203,24 @@ def Equivalence.toOrderIso (e : X ≌ Y) : X ≃o Y
       ((Equivalence.unit e).app a ≫ e.inverse.map h.Hom ≫ (Equivalence.unitInv e).app a').le,
       fun h : a ≤ a' => (e.Functor.map h.Hom).le⟩
 #align category_theory.equivalence.to_order_iso CategoryTheory.Equivalence.toOrderIso
+-/
 
+#print CategoryTheory.Equivalence.toOrderIso_apply /-
 -- `@[simps]` on `equivalence.to_order_iso` produces lemmas that fail the `simp_nf` linter,
 -- so we provide them by hand:
 @[simp]
 theorem Equivalence.toOrderIso_apply (e : X ≌ Y) (x : X) : e.toOrderIso x = e.Functor.obj x :=
   rfl
 #align category_theory.equivalence.to_order_iso_apply CategoryTheory.Equivalence.toOrderIso_apply
+-/
 
+#print CategoryTheory.Equivalence.toOrderIso_symm_apply /-
 @[simp]
 theorem Equivalence.toOrderIso_symm_apply (e : X ≌ Y) (y : Y) :
     e.toOrderIso.symm y = e.inverse.obj y :=
   rfl
 #align category_theory.equivalence.to_order_iso_symm_apply CategoryTheory.Equivalence.toOrderIso_symm_apply
+-/
 
 end PartialOrder
 

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

@@ -66,11 +66,13 @@ open Opposite
 
 variable {X : Type u} [Preorder X]
 
+#print CategoryTheory.homOfLE /-
 /-- Express an inequality as a morphism in the corresponding preorder category.
 -/
 def homOfLE {x y : X} (h : x ≤ y) : x ⟶ y :=
   ULift.up (PLift.up h)
 #align category_theory.hom_of_le CategoryTheory.homOfLE
+-/
 
 alias hom_of_le ← _root_.has_le.le.hom
 #align has_le.le.hom LE.le.hom
@@ -82,24 +84,30 @@ theorem homOfLE_refl {x : X} : (le_refl x).Hom = 𝟙 x :=
 #align category_theory.hom_of_le_refl CategoryTheory.homOfLE_refl
 -/
 
+#print CategoryTheory.homOfLE_comp /-
 @[simp]
 theorem homOfLE_comp {x y z : X} (h : x ≤ y) (k : y ≤ z) : h.Hom ≫ k.Hom = (h.trans k).Hom :=
   rfl
 #align category_theory.hom_of_le_comp CategoryTheory.homOfLE_comp
+-/
 
+#print CategoryTheory.leOfHom /-
 /-- Extract the underlying inequality from a morphism in a preorder category.
 -/
 theorem leOfHom {x y : X} (h : x ⟶ y) : x ≤ y :=
   h.down.down
 #align category_theory.le_of_hom CategoryTheory.leOfHom
+-/
 
 alias le_of_hom ← _root_.quiver.hom.le
 #align quiver.hom.le Quiver.Hom.le
 
+#print CategoryTheory.leOfHom_homOfLE /-
 @[simp]
 theorem leOfHom_homOfLE {x y : X} (h : x ≤ y) : h.Hom.le = h :=
   rfl
 #align category_theory.le_of_hom_hom_of_le CategoryTheory.leOfHom_homOfLE
+-/
 
 #print CategoryTheory.homOfLE_leOfHom /-
 @[simp]
@@ -107,14 +115,18 @@ theorem homOfLE_leOfHom {x y : X} (h : x ⟶ y) : h.le.Hom = h := by cases h; ca
 #align category_theory.hom_of_le_le_of_hom CategoryTheory.homOfLE_leOfHom
 -/
 
+#print CategoryTheory.opHomOfLE /-
 /-- Construct a morphism in the opposite of a preorder category from an inequality. -/
 def opHomOfLE {x y : Xᵒᵖ} (h : unop x ≤ unop y) : y ⟶ x :=
   h.Hom.op
 #align category_theory.op_hom_of_le CategoryTheory.opHomOfLE
+-/
 
+#print CategoryTheory.le_of_op_hom /-
 theorem le_of_op_hom {x y : Xᵒᵖ} (h : x ⟶ y) : unop y ≤ unop x :=
   h.unop.le
 #align category_theory.le_of_op_hom CategoryTheory.le_of_op_hom
+-/
 
 instance uniqueToTop [OrderTop X] {x : X} : Unique (x ⟶ ⊤) := by tidy
 #align category_theory.unique_to_top CategoryTheory.uniqueToTop

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

@@ -66,24 +66,12 @@ open Opposite
 
 variable {X : Type u} [Preorder X]
 
-/- warning: category_theory.hom_of_le -> CategoryTheory.homOfLE is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X}, (LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) x y) -> (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x y)
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X}, (LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) x y) -> (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x y)
-Case conversion may be inaccurate. Consider using '#align category_theory.hom_of_le CategoryTheory.homOfLEₓ'. -/
 /-- Express an inequality as a morphism in the corresponding preorder category.
 -/
 def homOfLE {x y : X} (h : x ≤ y) : x ⟶ y :=
   ULift.up (PLift.up h)
 #align category_theory.hom_of_le CategoryTheory.homOfLE
 
-/- warning: has_le.le.hom -> LE.le.hom is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X}, (LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) x y) -> (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x y)
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X}, (LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) x y) -> (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x y)
-Case conversion may be inaccurate. Consider using '#align has_le.le.hom LE.le.homₓ'. -/
 alias hom_of_le ← _root_.has_le.le.hom
 #align has_le.le.hom LE.le.hom
 
@@ -94,44 +82,20 @@ theorem homOfLE_refl {x : X} : (le_refl x).Hom = 𝟙 x :=
 #align category_theory.hom_of_le_refl CategoryTheory.homOfLE_refl
 -/
 
-/- warning: category_theory.hom_of_le_comp -> CategoryTheory.homOfLE_comp is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X} {z : X} (h : LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) x y) (k : LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) y z), Eq.{succ u1} (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x z) (CategoryTheory.CategoryStruct.comp.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1)) x y z (LE.le.hom.{u1} X _inst_1 x y h) (LE.le.hom.{u1} X _inst_1 y z k)) (LE.le.hom.{u1} X _inst_1 x z (LE.le.trans.{u1} X _inst_1 x y z h k))
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X} {z : X} (h : LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) x y) (k : LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) y z), Eq.{succ u1} (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x z) (CategoryTheory.CategoryStruct.comp.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1)) x y z (CategoryTheory.homOfLE.{u1} X _inst_1 x y h) (CategoryTheory.homOfLE.{u1} X _inst_1 y z k)) (CategoryTheory.homOfLE.{u1} X _inst_1 x z (LE.le.trans.{u1} X _inst_1 x y z h k))
-Case conversion may be inaccurate. Consider using '#align category_theory.hom_of_le_comp CategoryTheory.homOfLE_compₓ'. -/
 @[simp]
 theorem homOfLE_comp {x y z : X} (h : x ≤ y) (k : y ≤ z) : h.Hom ≫ k.Hom = (h.trans k).Hom :=
   rfl
 #align category_theory.hom_of_le_comp CategoryTheory.homOfLE_comp
 
-/- warning: category_theory.le_of_hom -> CategoryTheory.leOfHom is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X}, (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x y) -> (LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) x y)
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X}, (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x y) -> (LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) x y)
-Case conversion may be inaccurate. Consider using '#align category_theory.le_of_hom CategoryTheory.leOfHomₓ'. -/
 /-- Extract the underlying inequality from a morphism in a preorder category.
 -/
 theorem leOfHom {x y : X} (h : x ⟶ y) : x ≤ y :=
   h.down.down
 #align category_theory.le_of_hom CategoryTheory.leOfHom
 
-/- warning: quiver.hom.le -> Quiver.Hom.le is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X}, (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x y) -> (LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) x y)
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X}, (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x y) -> (LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) x y)
-Case conversion may be inaccurate. Consider using '#align quiver.hom.le Quiver.Hom.leₓ'. -/
 alias le_of_hom ← _root_.quiver.hom.le
 #align quiver.hom.le Quiver.Hom.le
 
-/- warning: category_theory.le_of_hom_hom_of_le -> CategoryTheory.leOfHom_homOfLE is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X} (h : LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) x y), Eq.{0} (LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) x y) (Quiver.Hom.le.{u1} X _inst_1 x y (LE.le.hom.{u1} X _inst_1 x y h)) h
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X} (h : LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) x y), Eq.{0} (LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) x y) (Quiver.Hom.le.{u1} X _inst_1 x y (LE.le.hom.{u1} X _inst_1 x y h)) h
-Case conversion may be inaccurate. Consider using '#align category_theory.le_of_hom_hom_of_le CategoryTheory.leOfHom_homOfLEₓ'. -/
 @[simp]
 theorem leOfHom_homOfLE {x y : X} (h : x ≤ y) : h.Hom.le = h :=
   rfl
@@ -143,42 +107,18 @@ theorem homOfLE_leOfHom {x y : X} (h : x ⟶ y) : h.le.Hom = h := by cases h; ca
 #align category_theory.hom_of_le_le_of_hom CategoryTheory.homOfLE_leOfHom
 -/
 
-/- warning: category_theory.op_hom_of_le -> CategoryTheory.opHomOfLE is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : Opposite.{succ u1} X} {y : Opposite.{succ u1} X}, (LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) (Opposite.unop.{succ u1} X x) (Opposite.unop.{succ u1} X y)) -> (Quiver.Hom.{succ u1, u1} (Opposite.{succ u1} X) (Quiver.opposite.{u1, succ u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1)))) y x)
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : Opposite.{succ u1} X} {y : Opposite.{succ u1} X}, (LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) (Opposite.unop.{succ u1} X x) (Opposite.unop.{succ u1} X y)) -> (Quiver.Hom.{succ u1, u1} (Opposite.{succ u1} X) (Quiver.opposite.{u1, succ u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1)))) y x)
-Case conversion may be inaccurate. Consider using '#align category_theory.op_hom_of_le CategoryTheory.opHomOfLEₓ'. -/
 /-- Construct a morphism in the opposite of a preorder category from an inequality. -/
 def opHomOfLE {x y : Xᵒᵖ} (h : unop x ≤ unop y) : y ⟶ x :=
   h.Hom.op
 #align category_theory.op_hom_of_le CategoryTheory.opHomOfLE
 
-/- warning: category_theory.le_of_op_hom -> CategoryTheory.le_of_op_hom is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : Opposite.{succ u1} X} {y : Opposite.{succ u1} X}, (Quiver.Hom.{succ u1, u1} (Opposite.{succ u1} X) (Quiver.opposite.{u1, succ u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1)))) x y) -> (LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) (Opposite.unop.{succ u1} X y) (Opposite.unop.{succ u1} X x))
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : Opposite.{succ u1} X} {y : Opposite.{succ u1} X}, (Quiver.Hom.{succ u1, u1} (Opposite.{succ u1} X) (Quiver.opposite.{u1, succ u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1)))) x y) -> (LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) (Opposite.unop.{succ u1} X y) (Opposite.unop.{succ u1} X x))
-Case conversion may be inaccurate. Consider using '#align category_theory.le_of_op_hom CategoryTheory.le_of_op_homₓ'. -/
 theorem le_of_op_hom {x y : Xᵒᵖ} (h : x ⟶ y) : unop y ≤ unop x :=
   h.unop.le
 #align category_theory.le_of_op_hom CategoryTheory.le_of_op_hom
 
-/- warning: category_theory.unique_to_top -> CategoryTheory.uniqueToTop is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] [_inst_2 : OrderTop.{u1} X (Preorder.toHasLe.{u1} X _inst_1)] {x : X}, Unique.{succ u1} (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x (Top.top.{u1} X (OrderTop.toHasTop.{u1} X (Preorder.toHasLe.{u1} X _inst_1) _inst_2)))
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] [_inst_2 : OrderTop.{u1} X (Preorder.toLE.{u1} X _inst_1)] {x : X}, Unique.{succ u1} (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x (Top.top.{u1} X (OrderTop.toTop.{u1} X (Preorder.toLE.{u1} X _inst_1) _inst_2)))
-Case conversion may be inaccurate. Consider using '#align category_theory.unique_to_top CategoryTheory.uniqueToTopₓ'. -/
 instance uniqueToTop [OrderTop X] {x : X} : Unique (x ⟶ ⊤) := by tidy
 #align category_theory.unique_to_top CategoryTheory.uniqueToTop
 
-/- warning: category_theory.unique_from_bot -> CategoryTheory.uniqueFromBot is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] [_inst_2 : OrderBot.{u1} X (Preorder.toHasLe.{u1} X _inst_1)] {x : X}, Unique.{succ u1} (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) (Bot.bot.{u1} X (OrderBot.toHasBot.{u1} X (Preorder.toHasLe.{u1} X _inst_1) _inst_2)) x)
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] [_inst_2 : OrderBot.{u1} X (Preorder.toLE.{u1} X _inst_1)] {x : X}, Unique.{succ u1} (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) (Bot.bot.{u1} X (OrderBot.toBot.{u1} X (Preorder.toLE.{u1} X _inst_1) _inst_2)) x)
-Case conversion may be inaccurate. Consider using '#align category_theory.unique_from_bot CategoryTheory.uniqueFromBotₓ'. -/
 instance uniqueFromBot [OrderBot X] {x : X} : Unique (⊥ ⟶ x) := by tidy
 #align category_theory.unique_from_bot CategoryTheory.uniqueFromBot
 
@@ -198,12 +138,6 @@ def Monotone.functor {f : X → Y} (h : Monotone f) : X ⥤ Y
 #align monotone.functor Monotone.functor
 -/
 
-/- warning: monotone.functor_obj -> Monotone.functor_obj is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : Preorder.{u1} X] [_inst_2 : Preorder.{u2} Y] {f : X -> Y} (h : Monotone.{u1, u2} X Y _inst_1 _inst_2 f), Eq.{max (succ u1) (succ u2)} (X -> Y) (CategoryTheory.Functor.obj.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X _inst_1) Y (Preorder.smallCategory.{u2} Y _inst_2) (Monotone.functor.{u1, u2} X Y _inst_1 _inst_2 f h)) f
-but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : Preorder.{u1} X] [_inst_2 : Preorder.{u2} Y] {f : X -> Y} (h : Monotone.{u1, u2} X Y _inst_1 _inst_2 f), Eq.{max (succ u1) (succ u2)} (X -> Y) (Prefunctor.obj.{succ u1, succ u2, u1, u2} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) Y (CategoryTheory.CategoryStruct.toQuiver.{u2, u2} Y (CategoryTheory.Category.toCategoryStruct.{u2, u2} Y (Preorder.smallCategory.{u2} Y _inst_2))) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X _inst_1) Y (Preorder.smallCategory.{u2} Y _inst_2) (Monotone.functor.{u1, u2} X Y _inst_1 _inst_2 f h))) f
-Case conversion may be inaccurate. Consider using '#align monotone.functor_obj Monotone.functor_objₓ'. -/
 @[simp]
 theorem Monotone.functor_obj {f : X → Y} (h : Monotone f) : h.Functor.obj = f :=
   rfl
@@ -217,12 +151,6 @@ section Preorder
 
 variable {X : Type u} {Y : Type v} [Preorder X] [Preorder Y]
 
-/- warning: category_theory.functor.monotone -> CategoryTheory.Functor.monotone is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : Preorder.{u1} X] [_inst_2 : Preorder.{u2} Y] (f : CategoryTheory.Functor.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X _inst_1) Y (Preorder.smallCategory.{u2} Y _inst_2)), Monotone.{u1, u2} X Y _inst_1 _inst_2 (CategoryTheory.Functor.obj.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X _inst_1) Y (Preorder.smallCategory.{u2} Y _inst_2) f)
-but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : Preorder.{u1} X] [_inst_2 : Preorder.{u2} Y] (f : CategoryTheory.Functor.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X _inst_1) Y (Preorder.smallCategory.{u2} Y _inst_2)), Monotone.{u1, u2} X Y _inst_1 _inst_2 (Prefunctor.obj.{succ u1, succ u2, u1, u2} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) Y (CategoryTheory.CategoryStruct.toQuiver.{u2, u2} Y (CategoryTheory.Category.toCategoryStruct.{u2, u2} Y (Preorder.smallCategory.{u2} Y _inst_2))) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X _inst_1) Y (Preorder.smallCategory.{u2} Y _inst_2) f))
-Case conversion may be inaccurate. Consider using '#align category_theory.functor.monotone CategoryTheory.Functor.monotoneₓ'. -/
 /-- A functor between preorder categories is monotone.
 -/
 @[mono]
@@ -241,12 +169,6 @@ theorem Iso.to_eq {x y : X} (f : x ≅ y) : x = y :=
 #align category_theory.iso.to_eq CategoryTheory.Iso.to_eq
 -/
 
-/- warning: category_theory.equivalence.to_order_iso -> CategoryTheory.Equivalence.toOrderIso is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y], (CategoryTheory.Equivalence.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) -> (OrderIso.{u1, u2} X Y (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))
-but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y], (CategoryTheory.Equivalence.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) -> (OrderIso.{u1, u2} X Y (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.to_order_iso CategoryTheory.Equivalence.toOrderIsoₓ'. -/
 /-- A categorical equivalence between partial orders is just an order isomorphism.
 -/
 def Equivalence.toOrderIso (e : X ≌ Y) : X ≃o Y
@@ -261,12 +183,6 @@ def Equivalence.toOrderIso (e : X ≌ Y) : X ≃o Y
       fun h : a ≤ a' => (e.Functor.map h.Hom).le⟩
 #align category_theory.equivalence.to_order_iso CategoryTheory.Equivalence.toOrderIso
 
-/- warning: category_theory.equivalence.to_order_iso_apply -> CategoryTheory.Equivalence.toOrderIso_apply is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (x : X), Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} X Y (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (fun (_x : RelIso.{u1, u2} X Y (LE.le.{u1} X (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1))) (LE.le.{u2} Y (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) => X -> Y) (RelIso.hasCoeToFun.{u1, u2} X Y (LE.le.{u1} X (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1))) (LE.le.{u2} Y (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e) x) (CategoryTheory.Functor.obj.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.functor.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e) x)
-but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (x : X), Eq.{succ u2} Y (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelIso.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) X (fun (_x : X) => Y) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelIso.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e) x) (Prefunctor.obj.{succ u1, succ u2, u1, u2} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) Y (CategoryTheory.CategoryStruct.toQuiver.{u2, u2} Y (CategoryTheory.Category.toCategoryStruct.{u2, u2} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.functor.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e)) x)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.to_order_iso_apply CategoryTheory.Equivalence.toOrderIso_applyₓ'. -/
 -- `@[simps]` on `equivalence.to_order_iso` produces lemmas that fail the `simp_nf` linter,
 -- so we provide them by hand:
 @[simp]
@@ -274,12 +190,6 @@ theorem Equivalence.toOrderIso_apply (e : X ≌ Y) (x : X) : e.toOrderIso x = e.
   rfl
 #align category_theory.equivalence.to_order_iso_apply CategoryTheory.Equivalence.toOrderIso_apply
 
-/- warning: category_theory.equivalence.to_order_iso_symm_apply -> CategoryTheory.Equivalence.toOrderIso_symm_apply is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (y : Y), Eq.{succ u1} X (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (OrderIso.{u2, u1} Y X (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1))) (fun (_x : RelIso.{u2, u1} Y X (LE.le.{u2} Y (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (LE.le.{u1} X (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) => Y -> X) (RelIso.hasCoeToFun.{u2, u1} Y X (LE.le.{u2} Y (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (LE.le.{u1} X (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) (OrderIso.symm.{u1, u2} X Y (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e)) y) (CategoryTheory.Functor.obj.{u2, u1, u2, u1} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (CategoryTheory.Equivalence.inverse.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e) y)
-but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (y : Y), Eq.{succ u1} X (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Y (fun (_x : Y) => X) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (OrderIso.symm.{u1, u2} X Y (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e)) y) (Prefunctor.obj.{succ u2, succ u1, u2, u1} Y (CategoryTheory.CategoryStruct.toQuiver.{u2, u2} Y (CategoryTheory.Category.toCategoryStruct.{u2, u2} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u2, u1} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (CategoryTheory.Equivalence.inverse.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e)) y)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.to_order_iso_symm_apply CategoryTheory.Equivalence.toOrderIso_symm_applyₓ'. -/
 @[simp]
 theorem Equivalence.toOrderIso_symm_apply (e : X ≌ Y) (y : Y) :
     e.toOrderIso.symm y = e.inverse.obj y :=

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

@@ -139,11 +139,7 @@ theorem leOfHom_homOfLE {x y : X} (h : x ≤ y) : h.Hom.le = h :=
 
 #print CategoryTheory.homOfLE_leOfHom /-
 @[simp]
-theorem homOfLE_leOfHom {x y : X} (h : x ⟶ y) : h.le.Hom = h :=
-  by
-  cases h
-  cases h
-  rfl
+theorem homOfLE_leOfHom {x y : X} (h : x ⟶ y) : h.le.Hom = h := by cases h; cases h; rfl
 #align category_theory.hom_of_le_le_of_hom CategoryTheory.homOfLE_leOfHom
 -/
 

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

@@ -147,16 +147,16 @@ theorem homOfLE_leOfHom {x y : X} (h : x ⟶ y) : h.le.Hom = h :=
 #align category_theory.hom_of_le_le_of_hom CategoryTheory.homOfLE_leOfHom
 -/
 
-/- warning: category_theory.op_hom_of_le -> CategoryTheory.opHomOfLe is a dubious translation:
+/- warning: category_theory.op_hom_of_le -> CategoryTheory.opHomOfLE is a dubious translation:
 lean 3 declaration is
   forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : Opposite.{succ u1} X} {y : Opposite.{succ u1} X}, (LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) (Opposite.unop.{succ u1} X x) (Opposite.unop.{succ u1} X y)) -> (Quiver.Hom.{succ u1, u1} (Opposite.{succ u1} X) (Quiver.opposite.{u1, succ u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1)))) y x)
 but is expected to have type
   forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : Opposite.{succ u1} X} {y : Opposite.{succ u1} X}, (LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) (Opposite.unop.{succ u1} X x) (Opposite.unop.{succ u1} X y)) -> (Quiver.Hom.{succ u1, u1} (Opposite.{succ u1} X) (Quiver.opposite.{u1, succ u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1)))) y x)
-Case conversion may be inaccurate. Consider using '#align category_theory.op_hom_of_le CategoryTheory.opHomOfLeₓ'. -/
+Case conversion may be inaccurate. Consider using '#align category_theory.op_hom_of_le CategoryTheory.opHomOfLEₓ'. -/
 /-- Construct a morphism in the opposite of a preorder category from an inequality. -/
-def opHomOfLe {x y : Xᵒᵖ} (h : unop x ≤ unop y) : y ⟶ x :=
+def opHomOfLE {x y : Xᵒᵖ} (h : unop x ≤ unop y) : y ⟶ x :=
   h.Hom.op
-#align category_theory.op_hom_of_le CategoryTheory.opHomOfLe
+#align category_theory.op_hom_of_le CategoryTheory.opHomOfLE
 
 /- warning: category_theory.le_of_op_hom -> CategoryTheory.le_of_op_hom is a dubious translation:
 lean 3 declaration is

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

@@ -269,7 +269,7 @@ def Equivalence.toOrderIso (e : X ≌ Y) : X ≃o Y
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (x : X), Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} X Y (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (fun (_x : RelIso.{u1, u2} X Y (LE.le.{u1} X (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1))) (LE.le.{u2} Y (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) => X -> Y) (RelIso.hasCoeToFun.{u1, u2} X Y (LE.le.{u1} X (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1))) (LE.le.{u2} Y (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e) x) (CategoryTheory.Functor.obj.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.functor.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e) x)
 but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (x : X), Eq.{succ u2} Y (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelIso.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) X (fun (_x : X) => Y) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelIso.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e) x) (Prefunctor.obj.{succ u1, succ u2, u1, u2} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) Y (CategoryTheory.CategoryStruct.toQuiver.{u2, u2} Y (CategoryTheory.Category.toCategoryStruct.{u2, u2} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.functor.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e)) x)
+  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (x : X), Eq.{succ u2} Y (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelIso.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) X (fun (_x : X) => Y) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelIso.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e) x) (Prefunctor.obj.{succ u1, succ u2, u1, u2} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) Y (CategoryTheory.CategoryStruct.toQuiver.{u2, u2} Y (CategoryTheory.Category.toCategoryStruct.{u2, u2} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.functor.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e)) x)
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.to_order_iso_apply CategoryTheory.Equivalence.toOrderIso_applyₓ'. -/
 -- `@[simps]` on `equivalence.to_order_iso` produces lemmas that fail the `simp_nf` linter,
 -- so we provide them by hand:
@@ -282,7 +282,7 @@ theorem Equivalence.toOrderIso_apply (e : X ≌ Y) (x : X) : e.toOrderIso x = e.
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (y : Y), Eq.{succ u1} X (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (OrderIso.{u2, u1} Y X (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1))) (fun (_x : RelIso.{u2, u1} Y X (LE.le.{u2} Y (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (LE.le.{u1} X (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) => Y -> X) (RelIso.hasCoeToFun.{u2, u1} Y X (LE.le.{u2} Y (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (LE.le.{u1} X (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) (OrderIso.symm.{u1, u2} X Y (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e)) y) (CategoryTheory.Functor.obj.{u2, u1, u2, u1} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (CategoryTheory.Equivalence.inverse.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e) y)
 but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (y : Y), Eq.{succ u1} X (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Y (fun (_x : Y) => X) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (OrderIso.symm.{u1, u2} X Y (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e)) y) (Prefunctor.obj.{succ u2, succ u1, u2, u1} Y (CategoryTheory.CategoryStruct.toQuiver.{u2, u2} Y (CategoryTheory.Category.toCategoryStruct.{u2, u2} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u2, u1} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (CategoryTheory.Equivalence.inverse.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e)) y)
+  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (y : Y), Eq.{succ u1} X (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Y (fun (_x : Y) => X) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (OrderIso.symm.{u1, u2} X Y (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e)) y) (Prefunctor.obj.{succ u2, succ u1, u2, u1} Y (CategoryTheory.CategoryStruct.toQuiver.{u2, u2} Y (CategoryTheory.Category.toCategoryStruct.{u2, u2} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u2, u1} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (CategoryTheory.Equivalence.inverse.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e)) y)
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.to_order_iso_symm_apply CategoryTheory.Equivalence.toOrderIso_symm_applyₓ'. -/
 @[simp]
 theorem Equivalence.toOrderIso_symm_apply (e : X ≌ Y) (y : Y) :

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

@@ -66,14 +66,24 @@ open Opposite
 
 variable {X : Type u} [Preorder X]
 
-#print CategoryTheory.homOfLE /-
+/- warning: category_theory.hom_of_le -> CategoryTheory.homOfLE is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X}, (LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) x y) -> (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x y)
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X}, (LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) x y) -> (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x y)
+Case conversion may be inaccurate. Consider using '#align category_theory.hom_of_le CategoryTheory.homOfLEₓ'. -/
 /-- Express an inequality as a morphism in the corresponding preorder category.
 -/
 def homOfLE {x y : X} (h : x ≤ y) : x ⟶ y :=
   ULift.up (PLift.up h)
 #align category_theory.hom_of_le CategoryTheory.homOfLE
--/
 
+/- warning: has_le.le.hom -> LE.le.hom is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X}, (LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) x y) -> (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x y)
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X}, (LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) x y) -> (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x y)
+Case conversion may be inaccurate. Consider using '#align has_le.le.hom LE.le.homₓ'. -/
 alias hom_of_le ← _root_.has_le.le.hom
 #align has_le.le.hom LE.le.hom
 
@@ -84,30 +94,48 @@ theorem homOfLE_refl {x : X} : (le_refl x).Hom = 𝟙 x :=
 #align category_theory.hom_of_le_refl CategoryTheory.homOfLE_refl
 -/
 
-#print CategoryTheory.homOfLE_comp /-
+/- warning: category_theory.hom_of_le_comp -> CategoryTheory.homOfLE_comp is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X} {z : X} (h : LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) x y) (k : LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) y z), Eq.{succ u1} (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x z) (CategoryTheory.CategoryStruct.comp.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1)) x y z (LE.le.hom.{u1} X _inst_1 x y h) (LE.le.hom.{u1} X _inst_1 y z k)) (LE.le.hom.{u1} X _inst_1 x z (LE.le.trans.{u1} X _inst_1 x y z h k))
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X} {z : X} (h : LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) x y) (k : LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) y z), Eq.{succ u1} (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x z) (CategoryTheory.CategoryStruct.comp.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1)) x y z (CategoryTheory.homOfLE.{u1} X _inst_1 x y h) (CategoryTheory.homOfLE.{u1} X _inst_1 y z k)) (CategoryTheory.homOfLE.{u1} X _inst_1 x z (LE.le.trans.{u1} X _inst_1 x y z h k))
+Case conversion may be inaccurate. Consider using '#align category_theory.hom_of_le_comp CategoryTheory.homOfLE_compₓ'. -/
 @[simp]
 theorem homOfLE_comp {x y z : X} (h : x ≤ y) (k : y ≤ z) : h.Hom ≫ k.Hom = (h.trans k).Hom :=
   rfl
 #align category_theory.hom_of_le_comp CategoryTheory.homOfLE_comp
--/
 
-#print CategoryTheory.leOfHom /-
+/- warning: category_theory.le_of_hom -> CategoryTheory.leOfHom is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X}, (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x y) -> (LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) x y)
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X}, (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x y) -> (LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) x y)
+Case conversion may be inaccurate. Consider using '#align category_theory.le_of_hom CategoryTheory.leOfHomₓ'. -/
 /-- Extract the underlying inequality from a morphism in a preorder category.
 -/
 theorem leOfHom {x y : X} (h : x ⟶ y) : x ≤ y :=
   h.down.down
 #align category_theory.le_of_hom CategoryTheory.leOfHom
--/
 
+/- warning: quiver.hom.le -> Quiver.Hom.le is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X}, (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x y) -> (LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) x y)
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X}, (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x y) -> (LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) x y)
+Case conversion may be inaccurate. Consider using '#align quiver.hom.le Quiver.Hom.leₓ'. -/
 alias le_of_hom ← _root_.quiver.hom.le
 #align quiver.hom.le Quiver.Hom.le
 
-#print CategoryTheory.leOfHom_homOfLE /-
+/- warning: category_theory.le_of_hom_hom_of_le -> CategoryTheory.leOfHom_homOfLE is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X} (h : LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) x y), Eq.{0} (LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) x y) (Quiver.Hom.le.{u1} X _inst_1 x y (LE.le.hom.{u1} X _inst_1 x y h)) h
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : X} {y : X} (h : LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) x y), Eq.{0} (LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) x y) (Quiver.Hom.le.{u1} X _inst_1 x y (LE.le.hom.{u1} X _inst_1 x y h)) h
+Case conversion may be inaccurate. Consider using '#align category_theory.le_of_hom_hom_of_le CategoryTheory.leOfHom_homOfLEₓ'. -/
 @[simp]
 theorem leOfHom_homOfLE {x y : X} (h : x ≤ y) : h.Hom.le = h :=
   rfl
 #align category_theory.le_of_hom_hom_of_le CategoryTheory.leOfHom_homOfLE
--/
 
 #print CategoryTheory.homOfLE_leOfHom /-
 @[simp]
@@ -119,22 +147,30 @@ theorem homOfLE_leOfHom {x y : X} (h : x ⟶ y) : h.le.Hom = h :=
 #align category_theory.hom_of_le_le_of_hom CategoryTheory.homOfLE_leOfHom
 -/
 
-#print CategoryTheory.opHomOfLe /-
+/- warning: category_theory.op_hom_of_le -> CategoryTheory.opHomOfLe is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : Opposite.{succ u1} X} {y : Opposite.{succ u1} X}, (LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) (Opposite.unop.{succ u1} X x) (Opposite.unop.{succ u1} X y)) -> (Quiver.Hom.{succ u1, u1} (Opposite.{succ u1} X) (Quiver.opposite.{u1, succ u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1)))) y x)
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : Opposite.{succ u1} X} {y : Opposite.{succ u1} X}, (LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) (Opposite.unop.{succ u1} X x) (Opposite.unop.{succ u1} X y)) -> (Quiver.Hom.{succ u1, u1} (Opposite.{succ u1} X) (Quiver.opposite.{u1, succ u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1)))) y x)
+Case conversion may be inaccurate. Consider using '#align category_theory.op_hom_of_le CategoryTheory.opHomOfLeₓ'. -/
 /-- Construct a morphism in the opposite of a preorder category from an inequality. -/
 def opHomOfLe {x y : Xᵒᵖ} (h : unop x ≤ unop y) : y ⟶ x :=
   h.Hom.op
 #align category_theory.op_hom_of_le CategoryTheory.opHomOfLe
--/
 
-#print CategoryTheory.le_of_op_hom /-
+/- warning: category_theory.le_of_op_hom -> CategoryTheory.le_of_op_hom is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : Opposite.{succ u1} X} {y : Opposite.{succ u1} X}, (Quiver.Hom.{succ u1, u1} (Opposite.{succ u1} X) (Quiver.opposite.{u1, succ u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1)))) x y) -> (LE.le.{u1} X (Preorder.toHasLe.{u1} X _inst_1) (Opposite.unop.{succ u1} X y) (Opposite.unop.{succ u1} X x))
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] {x : Opposite.{succ u1} X} {y : Opposite.{succ u1} X}, (Quiver.Hom.{succ u1, u1} (Opposite.{succ u1} X) (Quiver.opposite.{u1, succ u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1)))) x y) -> (LE.le.{u1} X (Preorder.toLE.{u1} X _inst_1) (Opposite.unop.{succ u1} X y) (Opposite.unop.{succ u1} X x))
+Case conversion may be inaccurate. Consider using '#align category_theory.le_of_op_hom CategoryTheory.le_of_op_homₓ'. -/
 theorem le_of_op_hom {x y : Xᵒᵖ} (h : x ⟶ y) : unop y ≤ unop x :=
   h.unop.le
 #align category_theory.le_of_op_hom CategoryTheory.le_of_op_hom
--/
 
 /- warning: category_theory.unique_to_top -> CategoryTheory.uniqueToTop is a dubious translation:
 lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] [_inst_2 : OrderTop.{u1} X (Preorder.toLE.{u1} X _inst_1)] {x : X}, Unique.{succ u1} (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x (Top.top.{u1} X (OrderTop.toHasTop.{u1} X (Preorder.toLE.{u1} X _inst_1) _inst_2)))
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] [_inst_2 : OrderTop.{u1} X (Preorder.toHasLe.{u1} X _inst_1)] {x : X}, Unique.{succ u1} (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x (Top.top.{u1} X (OrderTop.toHasTop.{u1} X (Preorder.toHasLe.{u1} X _inst_1) _inst_2)))
 but is expected to have type
   forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] [_inst_2 : OrderTop.{u1} X (Preorder.toLE.{u1} X _inst_1)] {x : X}, Unique.{succ u1} (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) x (Top.top.{u1} X (OrderTop.toTop.{u1} X (Preorder.toLE.{u1} X _inst_1) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align category_theory.unique_to_top CategoryTheory.uniqueToTopₓ'. -/
@@ -143,7 +179,7 @@ instance uniqueToTop [OrderTop X] {x : X} : Unique (x ⟶ ⊤) := by tidy
 
 /- warning: category_theory.unique_from_bot -> CategoryTheory.uniqueFromBot is a dubious translation:
 lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] [_inst_2 : OrderBot.{u1} X (Preorder.toLE.{u1} X _inst_1)] {x : X}, Unique.{succ u1} (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) (Bot.bot.{u1} X (OrderBot.toHasBot.{u1} X (Preorder.toLE.{u1} X _inst_1) _inst_2)) x)
+  forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] [_inst_2 : OrderBot.{u1} X (Preorder.toHasLe.{u1} X _inst_1)] {x : X}, Unique.{succ u1} (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) (Bot.bot.{u1} X (OrderBot.toHasBot.{u1} X (Preorder.toHasLe.{u1} X _inst_1) _inst_2)) x)
 but is expected to have type
   forall {X : Type.{u1}} [_inst_1 : Preorder.{u1} X] [_inst_2 : OrderBot.{u1} X (Preorder.toLE.{u1} X _inst_1)] {x : X}, Unique.{succ u1} (Quiver.Hom.{succ u1, u1} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X _inst_1))) (Bot.bot.{u1} X (OrderBot.toBot.{u1} X (Preorder.toLE.{u1} X _inst_1) _inst_2)) x)
 Case conversion may be inaccurate. Consider using '#align category_theory.unique_from_bot CategoryTheory.uniqueFromBotₓ'. -/
@@ -211,7 +247,7 @@ theorem Iso.to_eq {x y : X} (f : x ≅ y) : x = y :=
 
 /- warning: category_theory.equivalence.to_order_iso -> CategoryTheory.Equivalence.toOrderIso is a dubious translation:
 lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y], (CategoryTheory.Equivalence.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) -> (OrderIso.{u1, u2} X Y (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))
+  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y], (CategoryTheory.Equivalence.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) -> (OrderIso.{u1, u2} X Y (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))
 but is expected to have type
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y], (CategoryTheory.Equivalence.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) -> (OrderIso.{u1, u2} X Y (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.to_order_iso CategoryTheory.Equivalence.toOrderIsoₓ'. -/
@@ -231,7 +267,7 @@ def Equivalence.toOrderIso (e : X ≌ Y) : X ≃o Y
 
 /- warning: category_theory.equivalence.to_order_iso_apply -> CategoryTheory.Equivalence.toOrderIso_apply is a dubious translation:
 lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (x : X), Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} X Y (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (fun (_x : RelIso.{u1, u2} X Y (LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1))) (LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) => X -> Y) (RelIso.hasCoeToFun.{u1, u2} X Y (LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1))) (LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e) x) (CategoryTheory.Functor.obj.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.functor.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e) x)
+  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (x : X), Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} X Y (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (fun (_x : RelIso.{u1, u2} X Y (LE.le.{u1} X (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1))) (LE.le.{u2} Y (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) => X -> Y) (RelIso.hasCoeToFun.{u1, u2} X Y (LE.le.{u1} X (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1))) (LE.le.{u2} Y (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e) x) (CategoryTheory.Functor.obj.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.functor.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e) x)
 but is expected to have type
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (x : X), Eq.{succ u2} Y (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelIso.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) X (fun (_x : X) => Y) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelIso.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e) x) (Prefunctor.obj.{succ u1, succ u2, u1, u2} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) Y (CategoryTheory.CategoryStruct.toQuiver.{u2, u2} Y (CategoryTheory.Category.toCategoryStruct.{u2, u2} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.functor.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e)) x)
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.to_order_iso_apply CategoryTheory.Equivalence.toOrderIso_applyₓ'. -/
@@ -244,7 +280,7 @@ theorem Equivalence.toOrderIso_apply (e : X ≌ Y) (x : X) : e.toOrderIso x = e.
 
 /- warning: category_theory.equivalence.to_order_iso_symm_apply -> CategoryTheory.Equivalence.toOrderIso_symm_apply is a dubious translation:
 lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (y : Y), Eq.{succ u1} X (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (OrderIso.{u2, u1} Y X (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1))) (fun (_x : RelIso.{u2, u1} Y X (LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) => Y -> X) (RelIso.hasCoeToFun.{u2, u1} Y X (LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) (OrderIso.symm.{u1, u2} X Y (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e)) y) (CategoryTheory.Functor.obj.{u2, u1, u2, u1} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (CategoryTheory.Equivalence.inverse.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e) y)
+  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (y : Y), Eq.{succ u1} X (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (OrderIso.{u2, u1} Y X (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1))) (fun (_x : RelIso.{u2, u1} Y X (LE.le.{u2} Y (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (LE.le.{u1} X (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) => Y -> X) (RelIso.hasCoeToFun.{u2, u1} Y X (LE.le.{u2} Y (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (LE.le.{u1} X (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) (OrderIso.symm.{u1, u2} X Y (Preorder.toHasLe.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toHasLe.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e)) y) (CategoryTheory.Functor.obj.{u2, u1, u2, u1} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (CategoryTheory.Equivalence.inverse.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e) y)
 but is expected to have type
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (y : Y), Eq.{succ u1} X (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Y (fun (_x : Y) => X) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (OrderIso.symm.{u1, u2} X Y (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e)) y) (Prefunctor.obj.{succ u2, succ u1, u2, u1} Y (CategoryTheory.CategoryStruct.toQuiver.{u2, u2} Y (CategoryTheory.Category.toCategoryStruct.{u2, u2} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u2, u1} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (CategoryTheory.Equivalence.inverse.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e)) y)
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.to_order_iso_symm_apply CategoryTheory.Equivalence.toOrderIso_symm_applyₓ'. -/

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

@@ -233,7 +233,7 @@ def Equivalence.toOrderIso (e : X ≌ Y) : X ≃o Y
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (x : X), Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (OrderIso.{u1, u2} X Y (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (fun (_x : RelIso.{u1, u2} X Y (LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1))) (LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) => X -> Y) (RelIso.hasCoeToFun.{u1, u2} X Y (LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1))) (LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e) x) (CategoryTheory.Functor.obj.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.functor.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e) x)
 but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (x : X), Eq.{succ u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : X) => Y) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Function.Embedding.{succ u1, succ u2} X Y) X (fun (_x : X) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : X) => Y) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (Function.Embedding.{succ u1, succ u2} X Y) X Y (Function.instEmbeddingLikeEmbedding.{succ u1, succ u2} X Y)) (RelEmbedding.toEmbedding.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e))) x) (Prefunctor.obj.{succ u1, succ u2, u1, u2} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) Y (CategoryTheory.CategoryStruct.toQuiver.{u2, u2} Y (CategoryTheory.Category.toCategoryStruct.{u2, u2} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.functor.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e)) x)
+  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (x : X), Eq.{succ u2} Y (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelIso.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) X (fun (_x : X) => Y) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelIso.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u2} X Y (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e) x) (Prefunctor.obj.{succ u1, succ u2, u1, u2} X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) Y (CategoryTheory.CategoryStruct.toQuiver.{u2, u2} Y (CategoryTheory.Category.toCategoryStruct.{u2, u2} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.functor.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e)) x)
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.to_order_iso_apply CategoryTheory.Equivalence.toOrderIso_applyₓ'. -/
 -- `@[simps]` on `equivalence.to_order_iso` produces lemmas that fail the `simp_nf` linter,
 -- so we provide them by hand:
@@ -246,7 +246,7 @@ theorem Equivalence.toOrderIso_apply (e : X ≌ Y) (x : X) : e.toOrderIso x = e.
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (y : Y), Eq.{succ u1} X (coeFn.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (OrderIso.{u2, u1} Y X (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1))) (fun (_x : RelIso.{u2, u1} Y X (LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) => Y -> X) (RelIso.hasCoeToFun.{u2, u1} Y X (LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) (OrderIso.symm.{u1, u2} X Y (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e)) y) (CategoryTheory.Functor.obj.{u2, u1, u2, u1} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (CategoryTheory.Equivalence.inverse.{u1, u2, u1, u2} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e) y)
 but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (y : Y), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Y) => X) y) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} Y X) Y (fun (_x : Y) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Y) => X) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} Y X) Y X (Function.instEmbeddingLikeEmbedding.{succ u2, succ u1} Y X)) (RelEmbedding.toEmbedding.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (OrderIso.symm.{u1, u2} X Y (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e)))) y) (Prefunctor.obj.{succ u2, succ u1, u2, u1} Y (CategoryTheory.CategoryStruct.toQuiver.{u2, u2} Y (CategoryTheory.Category.toCategoryStruct.{u2, u2} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u2, u1} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (CategoryTheory.Equivalence.inverse.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e)) y)
+  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : PartialOrder.{u1} X] [_inst_2 : PartialOrder.{u2} Y] (e : CategoryTheory.Equivalence.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2))) (y : Y), Eq.{succ u1} X (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Y (fun (_x : Y) => X) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u2, u1} Y X (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Y) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Y) => LE.le.{u2} Y (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : X) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : X) => LE.le.{u1} X (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (OrderIso.symm.{u1, u2} X Y (Preorder.toLE.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.toLE.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) (CategoryTheory.Equivalence.toOrderIso.{u1, u2} X Y _inst_1 _inst_2 e)) y) (Prefunctor.obj.{succ u2, succ u1, u2, u1} Y (CategoryTheory.CategoryStruct.toQuiver.{u2, u2} Y (CategoryTheory.Category.toCategoryStruct.{u2, u2} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)))) X (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} X (CategoryTheory.Category.toCategoryStruct.{u1, u1} X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)))) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u2, u1} Y (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) X (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (CategoryTheory.Equivalence.inverse.{u1, u2, u1, u2} X Y (Preorder.smallCategory.{u1} X (PartialOrder.toPreorder.{u1} X _inst_1)) (Preorder.smallCategory.{u2} Y (PartialOrder.toPreorder.{u2} Y _inst_2)) e)) y)
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.to_order_iso_symm_apply CategoryTheory.Equivalence.toOrderIso_symm_applyₓ'. -/
 @[simp]
 theorem Equivalence.toOrderIso_symm_apply (e : X ≌ Y) (y : Y) :

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

Before this PR, Functor.Full contained the data of the preimage of maps by a full functor F. This PR makes Functor.Full a proposition. This is to prevent any diamond to appear.

The lemma Functor.image_preimage is also renamed Functor.map_preimage.

Co-authored-by: Joël Riou <37772949+joelriou@users.noreply.github.com>

@@ -145,7 +145,7 @@ theorem Monotone.functor_obj {f : X → Y} (h : Monotone f) : h.functor.obj = f
 
 -- Faithfulness is automatic because preorder categories are thin
 instance (f : X ↪o Y) : f.monotone.functor.Full where
-  preimage {x y} h := homOfLE (f.map_rel_iff.1 h.le)
+  map_surjective h := ⟨homOfLE (f.map_rel_iff.1 h.le), rfl⟩
 
 end
 

As discussed on Zulip.

@@ -143,6 +143,10 @@ theorem Monotone.functor_obj {f : X → Y} (h : Monotone f) : h.functor.obj = f
   rfl
 #align monotone.functor_obj Monotone.functor_obj
 
+-- Faithfulness is automatic because preorder categories are thin
+instance (f : X ↪o Y) : f.monotone.functor.Full where
+  preimage {x y} h := homOfLE (f.map_rel_iff.1 h.le)
+
 end
 
 namespace CategoryTheory

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

• converts "--porting note" into "-- Porting note";
• converts "porting note" into "Porting note".

@@ -50,7 +50,7 @@ instance (priority := 100) smallCategory (α : Type u) [Preorder α] : SmallCate
   comp f g := ⟨⟨le_trans _ _ _ f.down.down g.down.down⟩⟩
 #align preorder.small_category Preorder.smallCategory
 
--- porting note: added to ease the port of `CategoryTheory.Subobject.Basic`
+-- Porting note: added to ease the port of `CategoryTheory.Subobject.Basic`
 instance subsingleton_hom {α : Type u} [Preorder α] (U V : α) :
   Subsingleton (U ⟶ V) := ⟨fun _ _ => ULift.ext _ _ (Subsingleton.elim _ _ )⟩
 
@@ -91,13 +91,13 @@ theorem leOfHom {x y : X} (h : x ⟶ y) : x ≤ y :=
 alias _root_.Quiver.Hom.le := leOfHom
 #align quiver.hom.le Quiver.Hom.le
 
--- porting note: why does this lemma exist? With proof irrelevance, we don't need to simplify proofs
+-- Porting note: why does this lemma exist? With proof irrelevance, we don't need to simplify proofs
 -- @[simp]
 theorem leOfHom_homOfLE {x y : X} (h : x ≤ y) : h.hom.le = h :=
   rfl
 #align category_theory.le_of_hom_hom_of_le CategoryTheory.leOfHom_homOfLE
 
--- porting note: linter gives: "Left-hand side does not simplify, when using the simp lemma on
+-- Porting note: linter gives: "Left-hand side does not simplify, when using the simp lemma on
 -- itself. This usually means that it will never apply." removing simp? It doesn't fire
 -- @[simp]
 theorem homOfLE_leOfHom {x y : X} (h : x ⟶ y) : h.le.hom = h :=

@@ -51,7 +51,7 @@ instance (priority := 100) smallCategory (α : Type u) [Preorder α] : SmallCate
 #align preorder.small_category Preorder.smallCategory
 
 -- porting note: added to ease the port of `CategoryTheory.Subobject.Basic`
-instance Preorder.subsingleton_hom {α : Type u} [Preorder α] (U V : α) :
+instance subsingleton_hom {α : Type u} [Preorder α] (U V : α) :
   Subsingleton (U ⟶ V) := ⟨fun _ _ => ULift.ext _ _ (Subsingleton.elim _ _ )⟩
 
 end Preorder

@@ -68,7 +68,7 @@ def homOfLE {x y : X} (h : x ≤ y) : x ⟶ y :=
   ULift.up (PLift.up h)
 #align category_theory.hom_of_le CategoryTheory.homOfLE
 
-alias homOfLE ← _root_.LE.le.hom
+alias _root_.LE.le.hom := homOfLE
 #align has_le.le.hom LE.le.hom
 
 @[simp]
@@ -88,7 +88,7 @@ theorem leOfHom {x y : X} (h : x ⟶ y) : x ≤ y :=
   h.down.down
 #align category_theory.le_of_hom CategoryTheory.leOfHom
 
-alias leOfHom ← _root_.Quiver.Hom.le
+alias _root_.Quiver.Hom.le := leOfHom
 #align quiver.hom.le Quiver.Hom.le
 
 -- porting note: why does this lemma exist? With proof irrelevance, we don't need to simplify proofs

• depends on: #5966

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

@@ -2,16 +2,13 @@
 Copyright (c) 2017 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Stephen Morgan, Scott Morrison, Johannes Hölzl, Reid Barton
-
-! This file was ported from Lean 3 source module category_theory.category.preorder
-! leanprover-community/mathlib commit dc6c365e751e34d100e80fe6e314c3c3e0fd2988
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.CategoryTheory.Equivalence
 import Mathlib.Order.Hom.Basic
 import Mathlib.Data.ULift
 
+#align_import category_theory.category.preorder from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
+
 /-!
 
 # Preorders as categories

Make sure in particular one can import Mathlib.Tactic for teaching without getting category theory notations in scope. Note that only two files needed an extra open.

@@ -130,6 +130,8 @@ end CategoryTheory
 
 section
 
+open CategoryTheory
+
 variable {X : Type u} {Y : Type v} [Preorder X] [Preorder Y]
 
 /-- A monotone function between preorders induces a functor between the associated categories.

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Chris Hughes <chrishughes24@gmail.com>

@@ -108,9 +108,9 @@ theorem homOfLE_leOfHom {x y : X} (h : x ⟶ y) : h.le.hom = h :=
 #align category_theory.hom_of_le_le_of_hom CategoryTheory.homOfLE_leOfHom
 
 /-- Construct a morphism in the opposite of a preorder category from an inequality. -/
-def opHomOfLe {x y : Xᵒᵖ} (h : unop x ≤ unop y) : y ⟶ x :=
+def opHomOfLE {x y : Xᵒᵖ} (h : unop x ≤ unop y) : y ⟶ x :=
   (homOfLE h).op
-#align category_theory.op_hom_of_le CategoryTheory.opHomOfLe
+#align category_theory.op_hom_of_le CategoryTheory.opHomOfLE
 
 theorem le_of_op_hom {x y : Xᵒᵖ} (h : x ⟶ y) : unop y ≤ unop x :=
   h.unop.le

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>

@@ -10,6 +10,7 @@ Authors: Stephen Morgan, Scott Morrison, Johannes Hölzl, Reid Barton
 -/
 import Mathlib.CategoryTheory.Equivalence
 import Mathlib.Order.Hom.Basic
+import Mathlib.Data.ULift
 
 /-!
 
@@ -52,6 +53,10 @@ instance (priority := 100) smallCategory (α : Type u) [Preorder α] : SmallCate
   comp f g := ⟨⟨le_trans _ _ _ f.down.down g.down.down⟩⟩
 #align preorder.small_category Preorder.smallCategory
 
+-- porting note: added to ease the port of `CategoryTheory.Subobject.Basic`
+instance Preorder.subsingleton_hom {α : Type u} [Preorder α] (U V : α) :
+  Subsingleton (U ⟶ V) := ⟨fun _ _ => ULift.ext _ _ (Subsingleton.elim _ _ )⟩
+
 end Preorder
 
 namespace CategoryTheory

Restore most of the mono attribute now that #1740 is merged.

I think I got all of the monos.

@@ -149,7 +149,7 @@ variable {X : Type u} {Y : Type v} [Preorder X] [Preorder Y]
 
 /-- A functor between preorder categories is monotone.
 -/
--- @[mono] porting note: `mono` tactic is not ported yet
+@[mono]
 theorem Functor.monotone (f : X ⥤ Y) : Monotone f.obj := fun _ _ hxy => (f.map hxy.hom).le
 #align category_theory.functor.monotone CategoryTheory.Functor.monotone
 

@@ -41,16 +41,15 @@ open CategoryTheory
 The category structure coming from a preorder. There is a morphism `X ⟶ Y` if and only if `X ≤ Y`.
 
 Because we don't allow morphisms to live in `Prop`,
-we have to define `X ⟶ Y` as `ulift (plift (X ≤ Y))`.
+we have to define `X ⟶ Y` as `ULift (PLift (X ≤ Y))`.
 See `CategoryTheory.homOfLE` and `CategoryTheory.leOfHom`.
 
 See <https://stacks.math.columbia.edu/tag/00D3>.
 -/
-instance (priority := 100) smallCategory (α : Type u) [Preorder α] : SmallCategory α
-    where
+instance (priority := 100) smallCategory (α : Type u) [Preorder α] : SmallCategory α where
   Hom U V := ULift (PLift (U ≤ V))
   id X := ⟨⟨le_refl X⟩⟩
-  comp := @fun X Y Z f g => ⟨⟨le_trans _ _ _ f.down.down g.down.down⟩⟩
+  comp f g := ⟨⟨le_trans _ _ _ f.down.down g.down.down⟩⟩
 #align preorder.small_category Preorder.smallCategory
 
 end Preorder
@@ -96,11 +95,10 @@ theorem leOfHom_homOfLE {x y : X} (h : x ≤ y) : h.hom.le = h :=
   rfl
 #align category_theory.le_of_hom_hom_of_le CategoryTheory.leOfHom_homOfLE
 
--- porting note: why does this lemma exist? With proof irrelevance, we don't need to simplify proofs
+-- porting note: linter gives: "Left-hand side does not simplify, when using the simp lemma on
+-- itself. This usually means that it will never apply." removing simp? It doesn't fire
 -- @[simp]
-theorem homOfLE_leOfHom {x y : X} (h : x ⟶ y) : h.le.hom = h := by
-  cases' h with h
-  cases h
+theorem homOfLE_leOfHom {x y : X} (h : x ⟶ y) : h.le.hom = h :=
   rfl
 #align category_theory.hom_of_le_le_of_hom CategoryTheory.homOfLE_leOfHom
 

@@ -71,15 +71,15 @@ alias homOfLE ← _root_.LE.le.hom
 #align has_le.le.hom LE.le.hom
 
 @[simp]
-theorem hom_of_le_refl {x : X} : (le_refl x).hom = 𝟙 x :=
+theorem homOfLE_refl {x : X} : (le_refl x).hom = 𝟙 x :=
   rfl
-#align category_theory.hom_of_le_refl CategoryTheory.hom_of_le_refl
+#align category_theory.hom_of_le_refl CategoryTheory.homOfLE_refl
 
 @[simp]
-theorem hom_of_le_comp {x y z : X} (h : x ≤ y) (k : y ≤ z) :
+theorem homOfLE_comp {x y z : X} (h : x ≤ y) (k : y ≤ z) :
     homOfLE h ≫ homOfLE k = homOfLE (h.trans k) :=
   rfl
-#align category_theory.hom_of_le_comp CategoryTheory.hom_of_le_comp
+#align category_theory.hom_of_le_comp CategoryTheory.homOfLE_comp
 
 /-- Extract the underlying inequality from a morphism in a preorder category.
 -/
@@ -90,29 +90,28 @@ theorem leOfHom {x y : X} (h : x ⟶ y) : x ≤ y :=
 alias leOfHom ← _root_.Quiver.Hom.le
 #align quiver.hom.le Quiver.Hom.le
 
--- porting note: linter seems to be wrong here
-@[simp, nolint simpNF]
-theorem le_of_hom_hom_of_le {x y : X} (h : x ≤ y) : h.hom.le = h :=
+-- porting note: why does this lemma exist? With proof irrelevance, we don't need to simplify proofs
+-- @[simp]
+theorem leOfHom_homOfLE {x y : X} (h : x ≤ y) : h.hom.le = h :=
   rfl
-#align category_theory.le_of_hom_hom_of_le CategoryTheory.le_of_hom_hom_of_le
+#align category_theory.le_of_hom_hom_of_le CategoryTheory.leOfHom_homOfLE
 
--- porting note: linter gives: "Left-hand side does not simplify, when using the simp lemma on
--- itself. This usually means that it will never apply." removing simp? It doesn't fire
+-- porting note: why does this lemma exist? With proof irrelevance, we don't need to simplify proofs
 -- @[simp]
-theorem hom_of_le_le_of_hom {x y : X} (h : x ⟶ y) : h.le.hom = h := by
+theorem homOfLE_leOfHom {x y : X} (h : x ⟶ y) : h.le.hom = h := by
   cases' h with h
   cases h
   rfl
-#align category_theory.hom_of_le_le_of_hom CategoryTheory.hom_of_le_le_of_hom
+#align category_theory.hom_of_le_le_of_hom CategoryTheory.homOfLE_leOfHom
 
 /-- Construct a morphism in the opposite of a preorder category from an inequality. -/
 def opHomOfLe {x y : Xᵒᵖ} (h : unop x ≤ unop y) : y ⟶ x :=
   (homOfLE h).op
 #align category_theory.op_hom_of_le CategoryTheory.opHomOfLe
 
-theorem le_ofOp_hom {x y : Xᵒᵖ} (h : x ⟶ y) : unop y ≤ unop x :=
+theorem le_of_op_hom {x y : Xᵒᵖ} (h : x ⟶ y) : unop y ≤ unop x :=
   h.unop.le
-#align category_theory.le_of_op_hom CategoryTheory.le_ofOp_hom
+#align category_theory.le_of_op_hom CategoryTheory.le_of_op_hom
 
 instance uniqueToTop [OrderTop X] {x : X} : Unique (x ⟶ ⊤) where
   default := homOfLE le_top
@@ -132,10 +131,9 @@ variable {X : Type u} {Y : Type v} [Preorder X] [Preorder Y]
 
 /-- A monotone function between preorders induces a functor between the associated categories.
 -/
-def Monotone.functor {f : X → Y} (h : Monotone f) : X ⥤ Y
-    where
+def Monotone.functor {f : X → Y} (h : Monotone f) : X ⥤ Y where
   obj := f
-  map := @fun x₁ x₂ g => CategoryTheory.homOfLE (h g.le)
+  map g := CategoryTheory.homOfLE (h g.le)
 #align monotone.functor Monotone.functor
 
 @[simp]
@@ -169,13 +167,12 @@ theorem Iso.to_eq {x y : X} (f : x ≅ y) : x = y :=
 
 /-- A categorical equivalence between partial orders is just an order isomorphism.
 -/
-def Equivalence.toOrderIso (e : X ≌ Y) : X ≃o Y
-    where
+def Equivalence.toOrderIso (e : X ≌ Y) : X ≃o Y where
   toFun := e.functor.obj
   invFun := e.inverse.obj
   left_inv a := (e.unitIso.app a).to_eq.symm
   right_inv b := (e.counitIso.app b).to_eq
-  map_rel_iff' := @fun a a' =>
+  map_rel_iff' {a a'} :=
     ⟨fun h =>
       ((Equivalence.unit e).app a ≫ e.inverse.map h.hom ≫ (Equivalence.unitInv e).app a').le,
       fun h : a ≤ a' => (e.functor.map h.hom).le⟩

Co-authored-by: Moritz Firsching <firsching@google.com> Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Johan Commelin <johan@commelin.net>