order.category.LinOrd | Mathlib porting status

Changes since the initial port

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

Changes in mathlib3

e8ac6315

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

75be6b61

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
-import Mathbin.Order.Category.Lat
+import Order.Category.Lat
 
 #align_import order.category.LinOrd from "leanprover-community/mathlib"@"75be6b616681ab6ca66d798ead117e75cd64f125"
 
@@ -21,88 +21,88 @@ open CategoryTheory
 
 universe u
 
-#print LinOrdCat /-
+#print LinOrd /-
 /-- The category of linear orders. -/
-def LinOrdCat :=
+def LinOrd :=
   Bundled LinearOrder
-#align LinOrd LinOrdCat
+#align LinOrd LinOrd
 -/
 
-namespace LinOrdCat
+namespace LinOrd
 
 instance : BundledHom.ParentProjection @LinearOrder.toPartialOrder :=
   ⟨⟩
 
-deriving instance LargeCategory, ConcreteCategory for LinOrdCat
+deriving instance LargeCategory, ConcreteCategory for LinOrd
 
-instance : CoeSort LinOrdCat (Type _) :=
+instance : CoeSort LinOrd (Type _) :=
   Bundled.hasCoeToSort
 
-#print LinOrdCat.of /-
+#print LinOrd.of /-
 /-- Construct a bundled `LinOrd` from the underlying type and typeclass. -/
-def of (α : Type _) [LinearOrder α] : LinOrdCat :=
+def of (α : Type _) [LinearOrder α] : LinOrd :=
   Bundled.of α
-#align LinOrd.of LinOrdCat.of
+#align LinOrd.of LinOrd.of
 -/
 
-#print LinOrdCat.coe_of /-
+#print LinOrd.coe_of /-
 @[simp]
 theorem coe_of (α : Type _) [LinearOrder α] : ↥(of α) = α :=
   rfl
-#align LinOrd.coe_of LinOrdCat.coe_of
+#align LinOrd.coe_of LinOrd.coe_of
 -/
 
-instance : Inhabited LinOrdCat :=
+instance : Inhabited LinOrd :=
   ⟨of PUnit⟩
 
-instance (α : LinOrdCat) : LinearOrder α :=
+instance (α : LinOrd) : LinearOrder α :=
   α.str
 
-#print LinOrdCat.hasForgetToLatCat /-
-instance hasForgetToLatCat : HasForget₂ LinOrdCat LatCat
+#print LinOrd.hasForgetToLat /-
+instance hasForgetToLat : HasForget₂ LinOrd Lat
     where forget₂ :=
-    { obj := fun X => LatCat.of X
+    { obj := fun X => Lat.of X
       map := fun X Y f => (OrderHomClass.toLatticeHom X Y f : LatticeHom X Y) }
-#align LinOrd.has_forget_to_Lat LinOrdCat.hasForgetToLatCat
+#align LinOrd.has_forget_to_Lat LinOrd.hasForgetToLat
 -/
 
-#print LinOrdCat.Iso.mk /-
+#print LinOrd.Iso.mk /-
 /-- Constructs an equivalence between linear orders from an order isomorphism between them. -/
 @[simps]
-def Iso.mk {α β : LinOrdCat.{u}} (e : α ≃o β) : α ≅ β
+def Iso.mk {α β : LinOrd.{u}} (e : α ≃o β) : α ≅ β
     where
   Hom := e
   inv := e.symm
   hom_inv_id' := by ext; exact e.symm_apply_apply x
   inv_hom_id' := by ext; exact e.apply_symm_apply x
-#align LinOrd.iso.mk LinOrdCat.Iso.mk
+#align LinOrd.iso.mk LinOrd.Iso.mk
 -/
 
-#print LinOrdCat.dual /-
+#print LinOrd.dual /-
 /-- `order_dual` as a functor. -/
 @[simps]
-def dual : LinOrdCat ⥤ LinOrdCat where
+def dual : LinOrd ⥤ LinOrd where
   obj X := of Xᵒᵈ
   map X Y := OrderHom.dual
-#align LinOrd.dual LinOrdCat.dual
+#align LinOrd.dual LinOrd.dual
 -/
 
-#print LinOrdCat.dualEquiv /-
+#print LinOrd.dualEquiv /-
 /-- The equivalence between `LinOrd` and itself induced by `order_dual` both ways. -/
 @[simps Functor inverse]
-def dualEquiv : LinOrdCat ≌ LinOrdCat :=
+def dualEquiv : LinOrd ≌ LinOrd :=
   Equivalence.mk dual dual
     (NatIso.ofComponents (fun X => Iso.mk <| OrderIso.dualDual X) fun X Y f => rfl)
     (NatIso.ofComponents (fun X => Iso.mk <| OrderIso.dualDual X) fun X Y f => rfl)
-#align LinOrd.dual_equiv LinOrdCat.dualEquiv
+#align LinOrd.dual_equiv LinOrd.dualEquiv
 -/
 
-end LinOrdCat
+end LinOrd
 
-#print linOrdCat_dual_comp_forget_to_latCat /-
-theorem linOrdCat_dual_comp_forget_to_latCat :
-    LinOrdCat.dual ⋙ forget₂ LinOrdCat LatCat = forget₂ LinOrdCat LatCat ⋙ LatCat.dual :=
+#print linOrd_dual_comp_forget_to_Lat /-
+theorem linOrd_dual_comp_forget_to_Lat :
+    LinOrd.dual ⋙ forget₂ LinOrd Lat = forget₂ LinOrd Lat ⋙ Lat.dual :=
   rfl
-#align LinOrd_dual_comp_forget_to_Lat linOrdCat_dual_comp_forget_to_latCat
+#align LinOrd_dual_comp_forget_to_Lat linOrd_dual_comp_forget_to_Lat
 -/

75be6b61

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
-
-! This file was ported from Lean 3 source module order.category.LinOrd
-! leanprover-community/mathlib commit 75be6b616681ab6ca66d798ead117e75cd64f125
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Category.Lat
 
+#align_import order.category.LinOrd from "leanprover-community/mathlib"@"75be6b616681ab6ca66d798ead117e75cd64f125"
+
 /-!
 # Category of linear orders

75be6b61

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -61,11 +61,13 @@ instance : Inhabited LinOrdCat :=
 instance (α : LinOrdCat) : LinearOrder α :=
   α.str
 
+#print LinOrdCat.hasForgetToLatCat /-
 instance hasForgetToLatCat : HasForget₂ LinOrdCat LatCat
     where forget₂ :=
     { obj := fun X => LatCat.of X
       map := fun X Y f => (OrderHomClass.toLatticeHom X Y f : LatticeHom X Y) }
 #align LinOrd.has_forget_to_Lat LinOrdCat.hasForgetToLatCat
+-/
 
 #print LinOrdCat.Iso.mk /-
 /-- Constructs an equivalence between linear orders from an order isomorphism between them. -/
@@ -88,6 +90,7 @@ def dual : LinOrdCat ⥤ LinOrdCat where
 #align LinOrd.dual LinOrdCat.dual
 -/
 
+#print LinOrdCat.dualEquiv /-
 /-- The equivalence between `LinOrd` and itself induced by `order_dual` both ways. -/
 @[simps Functor inverse]
 def dualEquiv : LinOrdCat ≌ LinOrdCat :=
@@ -95,11 +98,14 @@ def dualEquiv : LinOrdCat ≌ LinOrdCat :=
     (NatIso.ofComponents (fun X => Iso.mk <| OrderIso.dualDual X) fun X Y f => rfl)
     (NatIso.ofComponents (fun X => Iso.mk <| OrderIso.dualDual X) fun X Y f => rfl)
 #align LinOrd.dual_equiv LinOrdCat.dualEquiv
+-/
 
 end LinOrdCat
 
+#print linOrdCat_dual_comp_forget_to_latCat /-
 theorem linOrdCat_dual_comp_forget_to_latCat :
     LinOrdCat.dual ⋙ forget₂ LinOrdCat LatCat = forget₂ LinOrdCat LatCat ⋙ LatCat.dual :=
   rfl
 #align LinOrd_dual_comp_forget_to_Lat linOrdCat_dual_comp_forget_to_latCat
+-/

75be6b61

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -67,6 +67,7 @@ instance hasForgetToLatCat : HasForget₂ LinOrdCat LatCat
       map := fun X Y f => (OrderHomClass.toLatticeHom X Y f : LatticeHom X Y) }
 #align LinOrd.has_forget_to_Lat LinOrdCat.hasForgetToLatCat
 
+#print LinOrdCat.Iso.mk /-
 /-- Constructs an equivalence between linear orders from an order isomorphism between them. -/
 @[simps]
 def Iso.mk {α β : LinOrdCat.{u}} (e : α ≃o β) : α ≅ β
@@ -76,6 +77,7 @@ def Iso.mk {α β : LinOrdCat.{u}} (e : α ≃o β) : α ≅ β
   hom_inv_id' := by ext; exact e.symm_apply_apply x
   inv_hom_id' := by ext; exact e.apply_symm_apply x
 #align LinOrd.iso.mk LinOrdCat.Iso.mk
+-/
 
 #print LinOrdCat.dual /-
 /-- `order_dual` as a functor. -/

75be6b61

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -61,24 +61,12 @@ instance : Inhabited LinOrdCat :=
 instance (α : LinOrdCat) : LinearOrder α :=
   α.str
 
-/- warning: LinOrd.has_forget_to_Lat -> LinOrdCat.hasForgetToLatCat is a dubious translation:
-lean 3 declaration is
-  CategoryTheory.HasForget₂.{succ u1, succ u1, u1, u1, u1} LinOrdCat.{u1} LatCat.{u1} LinOrdCat.largeCategory.{u1} LinOrdCat.concreteCategory.{u1} LatCat.CategoryTheory.largeCategory.{u1} LatCat.CategoryTheory.concreteCategory.{u1}
-but is expected to have type
-  CategoryTheory.HasForget₂.{succ u1, succ u1, u1, u1, u1} LinOrdCat.{u1} LatCat.{u1} instLinOrdCatLargeCategory.{u1} LinOrdCat.instConcreteCategoryLinOrdCatInstLinOrdCatLargeCategory.{u1} LatCat.instLargeCategoryLatCat.{u1} LatCat.instConcreteCategoryLatCatInstLargeCategoryLatCat.{u1}
-Case conversion may be inaccurate. Consider using '#align LinOrd.has_forget_to_Lat LinOrdCat.hasForgetToLatCatₓ'. -/
 instance hasForgetToLatCat : HasForget₂ LinOrdCat LatCat
     where forget₂ :=
     { obj := fun X => LatCat.of X
       map := fun X Y f => (OrderHomClass.toLatticeHom X Y f : LatticeHom X Y) }
 #align LinOrd.has_forget_to_Lat LinOrdCat.hasForgetToLatCat
 
-/- warning: LinOrd.iso.mk -> LinOrdCat.Iso.mk is a dubious translation:
-lean 3 declaration is
-  forall {α : LinOrdCat.{u1}} {β : LinOrdCat.{u1}}, (OrderIso.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} α) (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} β) (Preorder.toHasLe.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} α) (PartialOrder.toPreorder.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} α) (Lattice.toSemilatticeInf.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} α) (LinearOrder.toLattice.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} α) (LinOrdCat.linearOrder.{u1} α)))))) (Preorder.toHasLe.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} β) (PartialOrder.toPreorder.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} β) (SemilatticeInf.toPartialOrder.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} β) (Lattice.toSemilatticeInf.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} β) (LinearOrder.toLattice.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} β) (LinOrdCat.linearOrder.{u1} β))))))) -> (CategoryTheory.Iso.{u1, succ u1} LinOrdCat.{u1} LinOrdCat.largeCategory.{u1} α β)
-but is expected to have type
-  forall {α : LinOrdCat.{u1}} {β : LinOrdCat.{u1}}, (OrderIso.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} α) (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} β) (Preorder.toLE.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} α) (PartialOrder.toPreorder.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} α) (Lattice.toSemilatticeInf.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} α) (DistribLattice.toLattice.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} α) (instDistribLattice.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} α) (LinOrdCat.instLinearOrderα.{u1} α))))))) (Preorder.toLE.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} β) (PartialOrder.toPreorder.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} β) (SemilatticeInf.toPartialOrder.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} β) (Lattice.toSemilatticeInf.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} β) (DistribLattice.toLattice.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} β) (instDistribLattice.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} β) (LinOrdCat.instLinearOrderα.{u1} β)))))))) -> (CategoryTheory.Iso.{u1, succ u1} LinOrdCat.{u1} instLinOrdCatLargeCategory.{u1} α β)
-Case conversion may be inaccurate. Consider using '#align LinOrd.iso.mk LinOrdCat.Iso.mkₓ'. -/
 /-- Constructs an equivalence between linear orders from an order isomorphism between them. -/
 @[simps]
 def Iso.mk {α β : LinOrdCat.{u}} (e : α ≃o β) : α ≅ β
@@ -98,12 +86,6 @@ def dual : LinOrdCat ⥤ LinOrdCat where
 #align LinOrd.dual LinOrdCat.dual
 -/
 
-/- warning: LinOrd.dual_equiv -> LinOrdCat.dualEquiv is a dubious translation:
-lean 3 declaration is
-  CategoryTheory.Equivalence.{u1, u1, succ u1, succ u1} LinOrdCat.{u1} LinOrdCat.largeCategory.{u1} LinOrdCat.{u1} LinOrdCat.largeCategory.{u1}
-but is expected to have type
-  CategoryTheory.Equivalence.{u1, u1, succ u1, succ u1} LinOrdCat.{u1} LinOrdCat.{u1} instLinOrdCatLargeCategory.{u1} instLinOrdCatLargeCategory.{u1}
-Case conversion may be inaccurate. Consider using '#align LinOrd.dual_equiv LinOrdCat.dualEquivₓ'. -/
 /-- The equivalence between `LinOrd` and itself induced by `order_dual` both ways. -/
 @[simps Functor inverse]
 def dualEquiv : LinOrdCat ≌ LinOrdCat :=
@@ -114,12 +96,6 @@ def dualEquiv : LinOrdCat ≌ LinOrdCat :=
 
 end LinOrdCat
 
-/- warning: LinOrd_dual_comp_forget_to_Lat -> linOrdCat_dual_comp_forget_to_latCat is a dubious translation:
-lean 3 declaration is
-  Eq.{succ (succ u1)} (CategoryTheory.Functor.{u1, u1, succ u1, succ u1} LinOrdCat.{u1} LinOrdCat.largeCategory.{u1} LatCat.{u1} LatCat.CategoryTheory.largeCategory.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, succ u1, succ u1, succ u1} LinOrdCat.{u1} LinOrdCat.largeCategory.{u1} LinOrdCat.{u1} LinOrdCat.largeCategory.{u1} LatCat.{u1} LatCat.CategoryTheory.largeCategory.{u1} LinOrdCat.dual.{u1} (CategoryTheory.forget₂.{succ u1, succ u1, u1, u1, u1} LinOrdCat.{u1} LatCat.{u1} LinOrdCat.largeCategory.{u1} LinOrdCat.concreteCategory.{u1} LatCat.CategoryTheory.largeCategory.{u1} LatCat.CategoryTheory.concreteCategory.{u1} LinOrdCat.hasForgetToLatCat.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, succ u1, succ u1, succ u1} LinOrdCat.{u1} LinOrdCat.largeCategory.{u1} LatCat.{u1} LatCat.CategoryTheory.largeCategory.{u1} LatCat.{u1} LatCat.CategoryTheory.largeCategory.{u1} (CategoryTheory.forget₂.{succ u1, succ u1, u1, u1, u1} LinOrdCat.{u1} LatCat.{u1} LinOrdCat.largeCategory.{u1} LinOrdCat.concreteCategory.{u1} LatCat.CategoryTheory.largeCategory.{u1} LatCat.CategoryTheory.concreteCategory.{u1} LinOrdCat.hasForgetToLatCat.{u1}) LatCat.dual.{u1})
-but is expected to have type
-  Eq.{succ (succ u1)} (CategoryTheory.Functor.{u1, u1, succ u1, succ u1} LinOrdCat.{u1} instLinOrdCatLargeCategory.{u1} LatCat.{u1} LatCat.instLargeCategoryLatCat.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, succ u1, succ u1, succ u1} LinOrdCat.{u1} instLinOrdCatLargeCategory.{u1} LinOrdCat.{u1} instLinOrdCatLargeCategory.{u1} LatCat.{u1} LatCat.instLargeCategoryLatCat.{u1} LinOrdCat.dual.{u1} (CategoryTheory.forget₂.{succ u1, succ u1, u1, u1, u1} LinOrdCat.{u1} LatCat.{u1} instLinOrdCatLargeCategory.{u1} LinOrdCat.instConcreteCategoryLinOrdCatInstLinOrdCatLargeCategory.{u1} LatCat.instLargeCategoryLatCat.{u1} LatCat.instConcreteCategoryLatCatInstLargeCategoryLatCat.{u1} LinOrdCat.hasForgetToLatCat.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, succ u1, succ u1, succ u1} LinOrdCat.{u1} instLinOrdCatLargeCategory.{u1} LatCat.{u1} LatCat.instLargeCategoryLatCat.{u1} LatCat.{u1} LatCat.instLargeCategoryLatCat.{u1} (CategoryTheory.forget₂.{succ u1, succ u1, u1, u1, u1} LinOrdCat.{u1} LatCat.{u1} instLinOrdCatLargeCategory.{u1} LinOrdCat.instConcreteCategoryLinOrdCatInstLinOrdCatLargeCategory.{u1} LatCat.instLargeCategoryLatCat.{u1} LatCat.instConcreteCategoryLatCatInstLargeCategoryLatCat.{u1} LinOrdCat.hasForgetToLatCat.{u1}) LatCat.dual.{u1})
-Case conversion may be inaccurate. Consider using '#align LinOrd_dual_comp_forget_to_Lat linOrdCat_dual_comp_forget_to_latCatₓ'. -/
 theorem linOrdCat_dual_comp_forget_to_latCat :
     LinOrdCat.dual ⋙ forget₂ LinOrdCat LatCat = forget₂ LinOrdCat LatCat ⋙ LatCat.dual :=
   rfl

75be6b61

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -85,12 +85,8 @@ def Iso.mk {α β : LinOrdCat.{u}} (e : α ≃o β) : α ≅ β
     where
   Hom := e
   inv := e.symm
-  hom_inv_id' := by
-    ext
-    exact e.symm_apply_apply x
-  inv_hom_id' := by
-    ext
-    exact e.apply_symm_apply x
+  hom_inv_id' := by ext; exact e.symm_apply_apply x
+  inv_hom_id' := by ext; exact e.apply_symm_apply x
 #align LinOrd.iso.mk LinOrdCat.Iso.mk
 
 #print LinOrdCat.dual /-

75be6b61

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -73,7 +73,12 @@ instance hasForgetToLatCat : HasForget₂ LinOrdCat LatCat
       map := fun X Y f => (OrderHomClass.toLatticeHom X Y f : LatticeHom X Y) }
 #align LinOrd.has_forget_to_Lat LinOrdCat.hasForgetToLatCat
 
-#print LinOrdCat.Iso.mk /-
+/- warning: LinOrd.iso.mk -> LinOrdCat.Iso.mk is a dubious translation:
+lean 3 declaration is
+  forall {α : LinOrdCat.{u1}} {β : LinOrdCat.{u1}}, (OrderIso.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} α) (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} β) (Preorder.toHasLe.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} α) (PartialOrder.toPreorder.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} α) (Lattice.toSemilatticeInf.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} α) (LinearOrder.toLattice.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} α) (LinOrdCat.linearOrder.{u1} α)))))) (Preorder.toHasLe.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} β) (PartialOrder.toPreorder.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} β) (SemilatticeInf.toPartialOrder.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} β) (Lattice.toSemilatticeInf.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} β) (LinearOrder.toLattice.{u1} (coeSort.{succ (succ u1), succ (succ u1)} LinOrdCat.{u1} Type.{u1} LinOrdCat.hasCoeToSort.{u1} β) (LinOrdCat.linearOrder.{u1} β))))))) -> (CategoryTheory.Iso.{u1, succ u1} LinOrdCat.{u1} LinOrdCat.largeCategory.{u1} α β)
+but is expected to have type
+  forall {α : LinOrdCat.{u1}} {β : LinOrdCat.{u1}}, (OrderIso.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} α) (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} β) (Preorder.toLE.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} α) (PartialOrder.toPreorder.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} α) (Lattice.toSemilatticeInf.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} α) (DistribLattice.toLattice.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} α) (instDistribLattice.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} α) (LinOrdCat.instLinearOrderα.{u1} α))))))) (Preorder.toLE.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} β) (PartialOrder.toPreorder.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} β) (SemilatticeInf.toPartialOrder.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} β) (Lattice.toSemilatticeInf.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} β) (DistribLattice.toLattice.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} β) (instDistribLattice.{u1} (CategoryTheory.Bundled.α.{u1, u1} LinearOrder.{u1} β) (LinOrdCat.instLinearOrderα.{u1} β)))))))) -> (CategoryTheory.Iso.{u1, succ u1} LinOrdCat.{u1} instLinOrdCatLargeCategory.{u1} α β)
+Case conversion may be inaccurate. Consider using '#align LinOrd.iso.mk LinOrdCat.Iso.mkₓ'. -/
 /-- Constructs an equivalence between linear orders from an order isomorphism between them. -/
 @[simps]
 def Iso.mk {α β : LinOrdCat.{u}} (e : α ≃o β) : α ≅ β
@@ -87,7 +92,6 @@ def Iso.mk {α β : LinOrdCat.{u}} (e : α ≃o β) : α ≅ β
     ext
     exact e.apply_symm_apply x
 #align LinOrd.iso.mk LinOrdCat.Iso.mk
--/
 
 #print LinOrdCat.dual /-
 /-- `order_dual` as a functor. -/

75be6b61

bump to nightly-2023-04-07-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/5ec62c8106221a3f9160e4e4fcc3eed79fe213e9

3f979973

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 
 ! This file was ported from Lean 3 source module order.category.LinOrd
-! leanprover-community/mathlib commit e8ac6315bcfcbaf2d19a046719c3b553206dac75
+! leanprover-community/mathlib commit 75be6b616681ab6ca66d798ead117e75cd64f125
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.Order.Category.Lat
 /-!
 # Category of linear orders
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 This defines `LinOrd`, the category of linear orders with monotone maps.
 -/

e8ac6315

bump to nightly-2023-04-05-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/1a4df69ca1a9a0e5e26bfe12e2b92814216016d0

523f1e96

Diff

@@ -21,46 +21,59 @@ open CategoryTheory
 
 universe u
 
+#print LinOrdCat /-
 /-- The category of linear orders. -/
-def LinOrd :=
+def LinOrdCat :=
   Bundled LinearOrder
-#align LinOrd LinOrd
+#align LinOrd LinOrdCat
+-/
 
-namespace LinOrd
+namespace LinOrdCat
 
 instance : BundledHom.ParentProjection @LinearOrder.toPartialOrder :=
   ⟨⟩
 
-deriving instance LargeCategory, ConcreteCategory for LinOrd
+deriving instance LargeCategory, ConcreteCategory for LinOrdCat
 
-instance : CoeSort LinOrd (Type _) :=
+instance : CoeSort LinOrdCat (Type _) :=
   Bundled.hasCoeToSort
 
+#print LinOrdCat.of /-
 /-- Construct a bundled `LinOrd` from the underlying type and typeclass. -/
-def of (α : Type _) [LinearOrder α] : LinOrd :=
+def of (α : Type _) [LinearOrder α] : LinOrdCat :=
   Bundled.of α
-#align LinOrd.of LinOrd.of
+#align LinOrd.of LinOrdCat.of
+-/
 
+#print LinOrdCat.coe_of /-
 @[simp]
 theorem coe_of (α : Type _) [LinearOrder α] : ↥(of α) = α :=
   rfl
-#align LinOrd.coe_of LinOrd.coe_of
+#align LinOrd.coe_of LinOrdCat.coe_of
+-/
 
-instance : Inhabited LinOrd :=
+instance : Inhabited LinOrdCat :=
   ⟨of PUnit⟩
 
-instance (α : LinOrd) : LinearOrder α :=
+instance (α : LinOrdCat) : LinearOrder α :=
   α.str
 
-instance hasForgetToLat : HasForget₂ LinOrd Lat
+/- warning: LinOrd.has_forget_to_Lat -> LinOrdCat.hasForgetToLatCat is a dubious translation:
+lean 3 declaration is
+  CategoryTheory.HasForget₂.{succ u1, succ u1, u1, u1, u1} LinOrdCat.{u1} LatCat.{u1} LinOrdCat.largeCategory.{u1} LinOrdCat.concreteCategory.{u1} LatCat.CategoryTheory.largeCategory.{u1} LatCat.CategoryTheory.concreteCategory.{u1}
+but is expected to have type
+  CategoryTheory.HasForget₂.{succ u1, succ u1, u1, u1, u1} LinOrdCat.{u1} LatCat.{u1} instLinOrdCatLargeCategory.{u1} LinOrdCat.instConcreteCategoryLinOrdCatInstLinOrdCatLargeCategory.{u1} LatCat.instLargeCategoryLatCat.{u1} LatCat.instConcreteCategoryLatCatInstLargeCategoryLatCat.{u1}
+Case conversion may be inaccurate. Consider using '#align LinOrd.has_forget_to_Lat LinOrdCat.hasForgetToLatCatₓ'. -/
+instance hasForgetToLatCat : HasForget₂ LinOrdCat LatCat
     where forget₂ :=
-    { obj := fun X => Lat.of X
+    { obj := fun X => LatCat.of X
       map := fun X Y f => (OrderHomClass.toLatticeHom X Y f : LatticeHom X Y) }
-#align LinOrd.has_forget_to_Lat LinOrd.hasForgetToLat
+#align LinOrd.has_forget_to_Lat LinOrdCat.hasForgetToLatCat
 
+#print LinOrdCat.Iso.mk /-
 /-- Constructs an equivalence between linear orders from an order isomorphism between them. -/
 @[simps]
-def Iso.mk {α β : LinOrd.{u}} (e : α ≃o β) : α ≅ β
+def Iso.mk {α β : LinOrdCat.{u}} (e : α ≃o β) : α ≅ β
     where
   Hom := e
   inv := e.symm
@@ -70,27 +83,42 @@ def Iso.mk {α β : LinOrd.{u}} (e : α ≃o β) : α ≅ β
   inv_hom_id' := by
     ext
     exact e.apply_symm_apply x
-#align LinOrd.iso.mk LinOrd.Iso.mk
+#align LinOrd.iso.mk LinOrdCat.Iso.mk
+-/
 
+#print LinOrdCat.dual /-
 /-- `order_dual` as a functor. -/
 @[simps]
-def dual : LinOrd ⥤ LinOrd where
+def dual : LinOrdCat ⥤ LinOrdCat where
   obj X := of Xᵒᵈ
   map X Y := OrderHom.dual
-#align LinOrd.dual LinOrd.dual
+#align LinOrd.dual LinOrdCat.dual
+-/
 
+/- warning: LinOrd.dual_equiv -> LinOrdCat.dualEquiv is a dubious translation:
+lean 3 declaration is
+  CategoryTheory.Equivalence.{u1, u1, succ u1, succ u1} LinOrdCat.{u1} LinOrdCat.largeCategory.{u1} LinOrdCat.{u1} LinOrdCat.largeCategory.{u1}
+but is expected to have type
+  CategoryTheory.Equivalence.{u1, u1, succ u1, succ u1} LinOrdCat.{u1} LinOrdCat.{u1} instLinOrdCatLargeCategory.{u1} instLinOrdCatLargeCategory.{u1}
+Case conversion may be inaccurate. Consider using '#align LinOrd.dual_equiv LinOrdCat.dualEquivₓ'. -/
 /-- The equivalence between `LinOrd` and itself induced by `order_dual` both ways. -/
 @[simps Functor inverse]
-def dualEquiv : LinOrd ≌ LinOrd :=
+def dualEquiv : LinOrdCat ≌ LinOrdCat :=
   Equivalence.mk dual dual
     (NatIso.ofComponents (fun X => Iso.mk <| OrderIso.dualDual X) fun X Y f => rfl)
     (NatIso.ofComponents (fun X => Iso.mk <| OrderIso.dualDual X) fun X Y f => rfl)
-#align LinOrd.dual_equiv LinOrd.dualEquiv
-
-end LinOrd
-
-theorem linOrd_dual_comp_forget_to_lat :
-    LinOrd.dual ⋙ forget₂ LinOrd Lat = forget₂ LinOrd Lat ⋙ Lat.dual :=
+#align LinOrd.dual_equiv LinOrdCat.dualEquiv
+
+end LinOrdCat
+
+/- warning: LinOrd_dual_comp_forget_to_Lat -> linOrdCat_dual_comp_forget_to_latCat is a dubious translation:
+lean 3 declaration is
+  Eq.{succ (succ u1)} (CategoryTheory.Functor.{u1, u1, succ u1, succ u1} LinOrdCat.{u1} LinOrdCat.largeCategory.{u1} LatCat.{u1} LatCat.CategoryTheory.largeCategory.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, succ u1, succ u1, succ u1} LinOrdCat.{u1} LinOrdCat.largeCategory.{u1} LinOrdCat.{u1} LinOrdCat.largeCategory.{u1} LatCat.{u1} LatCat.CategoryTheory.largeCategory.{u1} LinOrdCat.dual.{u1} (CategoryTheory.forget₂.{succ u1, succ u1, u1, u1, u1} LinOrdCat.{u1} LatCat.{u1} LinOrdCat.largeCategory.{u1} LinOrdCat.concreteCategory.{u1} LatCat.CategoryTheory.largeCategory.{u1} LatCat.CategoryTheory.concreteCategory.{u1} LinOrdCat.hasForgetToLatCat.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, succ u1, succ u1, succ u1} LinOrdCat.{u1} LinOrdCat.largeCategory.{u1} LatCat.{u1} LatCat.CategoryTheory.largeCategory.{u1} LatCat.{u1} LatCat.CategoryTheory.largeCategory.{u1} (CategoryTheory.forget₂.{succ u1, succ u1, u1, u1, u1} LinOrdCat.{u1} LatCat.{u1} LinOrdCat.largeCategory.{u1} LinOrdCat.concreteCategory.{u1} LatCat.CategoryTheory.largeCategory.{u1} LatCat.CategoryTheory.concreteCategory.{u1} LinOrdCat.hasForgetToLatCat.{u1}) LatCat.dual.{u1})
+but is expected to have type
+  Eq.{succ (succ u1)} (CategoryTheory.Functor.{u1, u1, succ u1, succ u1} LinOrdCat.{u1} instLinOrdCatLargeCategory.{u1} LatCat.{u1} LatCat.instLargeCategoryLatCat.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, succ u1, succ u1, succ u1} LinOrdCat.{u1} instLinOrdCatLargeCategory.{u1} LinOrdCat.{u1} instLinOrdCatLargeCategory.{u1} LatCat.{u1} LatCat.instLargeCategoryLatCat.{u1} LinOrdCat.dual.{u1} (CategoryTheory.forget₂.{succ u1, succ u1, u1, u1, u1} LinOrdCat.{u1} LatCat.{u1} instLinOrdCatLargeCategory.{u1} LinOrdCat.instConcreteCategoryLinOrdCatInstLinOrdCatLargeCategory.{u1} LatCat.instLargeCategoryLatCat.{u1} LatCat.instConcreteCategoryLatCatInstLargeCategoryLatCat.{u1} LinOrdCat.hasForgetToLatCat.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, succ u1, succ u1, succ u1} LinOrdCat.{u1} instLinOrdCatLargeCategory.{u1} LatCat.{u1} LatCat.instLargeCategoryLatCat.{u1} LatCat.{u1} LatCat.instLargeCategoryLatCat.{u1} (CategoryTheory.forget₂.{succ u1, succ u1, u1, u1, u1} LinOrdCat.{u1} LatCat.{u1} instLinOrdCatLargeCategory.{u1} LinOrdCat.instConcreteCategoryLinOrdCatInstLinOrdCatLargeCategory.{u1} LatCat.instLargeCategoryLatCat.{u1} LatCat.instConcreteCategoryLatCatInstLargeCategoryLatCat.{u1} LinOrdCat.hasForgetToLatCat.{u1}) LatCat.dual.{u1})
+Case conversion may be inaccurate. Consider using '#align LinOrd_dual_comp_forget_to_Lat linOrdCat_dual_comp_forget_to_latCatₓ'. -/
+theorem linOrdCat_dual_comp_forget_to_latCat :
+    LinOrdCat.dual ⋙ forget₂ LinOrdCat LatCat = forget₂ LinOrdCat LatCat ⋙ LatCat.dual :=
   rfl
-#align LinOrd_dual_comp_forget_to_Lat linOrd_dual_comp_forget_to_lat
+#align LinOrd_dual_comp_forget_to_Lat linOrdCat_dual_comp_forget_to_latCat

e8ac6315

bump to nightly-2023-03-30-02

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

af7dd13c

Changes in mathlib4

mathlib3

mathlib4

e8ac6315

chore: Remove Cat suffixes (#3730)

These names needn't change in the first place.

40fe5127

Diff

@@ -3,14 +3,14 @@ Copyright (c) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
-import Mathlib.Order.Category.LatCat
+import Mathlib.Order.Category.Lat
 
 #align_import order.category.LinOrd from "leanprover-community/mathlib"@"e8ac6315bcfcbaf2d19a046719c3b553206dac75"
 
 /-!
 # Category of linear orders
 
-This defines `LinOrdCat`, the category of linear orders with monotone maps.
+This defines `LinOrd`, the category of linear orders with monotone maps.
 -/
 
 
@@ -19,53 +19,53 @@ open CategoryTheory
 universe u
 
 /-- The category of linear orders. -/
-def LinOrdCat :=
+def LinOrd :=
   Bundled LinearOrder
 set_option linter.uppercaseLean3 false in
-#align LinOrd LinOrdCat
+#align LinOrd LinOrd
 
-namespace LinOrdCat
+namespace LinOrd
 
 instance : BundledHom.ParentProjection @LinearOrder.toPartialOrder :=
   ⟨⟩
 
-deriving instance LargeCategory for LinOrdCat
+deriving instance LargeCategory for LinOrd
 
 -- Porting note: Probably see https://github.com/leanprover-community/mathlib4/issues/5020
-instance : ConcreteCategory LinOrdCat :=
+instance : ConcreteCategory LinOrd :=
   BundledHom.concreteCategory _
 
-instance : CoeSort LinOrdCat (Type*) :=
+instance : CoeSort LinOrd Type* :=
   Bundled.coeSort
 
-/-- Construct a bundled `LinOrdCat` from the underlying type and typeclass. -/
-def of (α : Type*) [LinearOrder α] : LinOrdCat :=
+/-- Construct a bundled `LinOrd` from the underlying type and typeclass. -/
+def of (α : Type*) [LinearOrder α] : LinOrd :=
   Bundled.of α
 set_option linter.uppercaseLean3 false in
-#align LinOrd.of LinOrdCat.of
+#align LinOrd.of LinOrd.of
 
 @[simp]
 theorem coe_of (α : Type*) [LinearOrder α] : ↥(of α) = α :=
   rfl
 set_option linter.uppercaseLean3 false in
-#align LinOrd.coe_of LinOrdCat.coe_of
+#align LinOrd.coe_of LinOrd.coe_of
 
-instance : Inhabited LinOrdCat :=
+instance : Inhabited LinOrd :=
   ⟨of PUnit⟩
 
-instance (α : LinOrdCat) : LinearOrder α :=
+instance (α : LinOrd) : LinearOrder α :=
   α.str
 
-instance hasForgetToLatCat : HasForget₂ LinOrdCat LatCat where
+instance hasForgetToLat : HasForget₂ LinOrd Lat where
   forget₂ :=
-    { obj := fun X => LatCat.of X
+    { obj := fun X => Lat.of X
       map := fun {X Y} (f : OrderHom _ _) => OrderHomClass.toLatticeHom X Y f }
 set_option linter.uppercaseLean3 false in
-#align LinOrd.has_forget_to_Lat LinOrdCat.hasForgetToLatCat
+#align LinOrd.has_forget_to_Lat LinOrd.hasForgetToLat
 
 /-- Constructs an equivalence between linear orders from an order isomorphism between them. -/
 @[simps]
-def Iso.mk {α β : LinOrdCat.{u}} (e : α ≃o β) : α ≅ β where
+def Iso.mk {α β : LinOrd.{u}} (e : α ≃o β) : α ≅ β where
   hom := (e : OrderHom _ _)
   inv := (e.symm : OrderHom _ _)
   hom_inv_id := by
@@ -75,30 +75,30 @@ def Iso.mk {α β : LinOrdCat.{u}} (e : α ≃o β) : α ≅ β where
     ext x
     exact e.apply_symm_apply x
 set_option linter.uppercaseLean3 false in
-#align LinOrd.iso.mk LinOrdCat.Iso.mk
+#align LinOrd.iso.mk LinOrd.Iso.mk
 
 /-- `OrderDual` as a functor. -/
 @[simps]
-def dual : LinOrdCat ⥤ LinOrdCat where
+def dual : LinOrd ⥤ LinOrd where
   obj X := of Xᵒᵈ
   map := OrderHom.dual
 set_option linter.uppercaseLean3 false in
-#align LinOrd.dual LinOrdCat.dual
+#align LinOrd.dual LinOrd.dual
 
-/-- The equivalence between `LinOrdCat` and itself induced by `OrderDual` both ways. -/
+/-- The equivalence between `LinOrd` and itself induced by `OrderDual` both ways. -/
 @[simps functor inverse]
-def dualEquiv : LinOrdCat ≌ LinOrdCat where
+def dualEquiv : LinOrd ≌ LinOrd where
   functor := dual
   inverse := dual
   unitIso := NatIso.ofComponents fun X => Iso.mk <| OrderIso.dualDual X
   counitIso := NatIso.ofComponents fun X => Iso.mk <| OrderIso.dualDual X
 set_option linter.uppercaseLean3 false in
-#align LinOrd.dual_equiv LinOrdCat.dualEquiv
+#align LinOrd.dual_equiv LinOrd.dualEquiv
 
-end LinOrdCat
+end LinOrd
 
-theorem linOrdCat_dual_comp_forget_to_latCat :
-    LinOrdCat.dual ⋙ forget₂ LinOrdCat LatCat = forget₂ LinOrdCat LatCat ⋙ LatCat.dual :=
+theorem linOrd_dual_comp_forget_to_Lat :
+    LinOrd.dual ⋙ forget₂ LinOrd Lat = forget₂ LinOrd Lat ⋙ Lat.dual :=
   rfl
 set_option linter.uppercaseLean3 false in
-#align LinOrd_dual_comp_forget_to_Lat linOrdCat_dual_comp_forget_to_latCat
+#align LinOrd_dual_comp_forget_to_Lat linOrd_dual_comp_forget_to_Lat

e8ac6315

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

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

This has nice performance benefits.

32de3f67

Diff

@@ -35,17 +35,17 @@ deriving instance LargeCategory for LinOrdCat
 instance : ConcreteCategory LinOrdCat :=
   BundledHom.concreteCategory _
 
-instance : CoeSort LinOrdCat (Type _) :=
+instance : CoeSort LinOrdCat (Type*) :=
   Bundled.coeSort
 
 /-- Construct a bundled `LinOrdCat` from the underlying type and typeclass. -/
-def of (α : Type _) [LinearOrder α] : LinOrdCat :=
+def of (α : Type*) [LinearOrder α] : LinOrdCat :=
   Bundled.of α
 set_option linter.uppercaseLean3 false in
 #align LinOrd.of LinOrdCat.of
 
 @[simp]
-theorem coe_of (α : Type _) [LinearOrder α] : ↥(of α) = α :=
+theorem coe_of (α : Type*) [LinearOrder α] : ↥(of α) = α :=
   rfl
 set_option linter.uppercaseLean3 false in
 #align LinOrd.coe_of LinOrdCat.coe_of

e8ac6315

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
-
-! This file was ported from Lean 3 source module order.category.LinOrd
-! leanprover-community/mathlib commit e8ac6315bcfcbaf2d19a046719c3b553206dac75
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.Category.LatCat
 
+#align_import order.category.LinOrd from "leanprover-community/mathlib"@"e8ac6315bcfcbaf2d19a046719c3b553206dac75"
+
 /-!
 # Category of linear orders

e8ac6315

feat: port Order.Category.HeytAlgCat (#5021)

Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

fc5d0810

Diff

@@ -34,6 +34,7 @@ instance : BundledHom.ParentProjection @LinearOrder.toPartialOrder :=
 
 deriving instance LargeCategory for LinOrdCat
 
+-- Porting note: Probably see https://github.com/leanprover-community/mathlib4/issues/5020
 instance : ConcreteCategory LinOrdCat :=
   BundledHom.concreteCategory _

e8ac6315

chore: review of automation in category theory (#4793)

Clean up of automation in the category theory library. Leaving out unnecessary proof steps, or fields done by aesop_cat, and making more use of available autoparameters.

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

5b958613

Diff

@@ -92,8 +92,8 @@ set_option linter.uppercaseLean3 false in
 def dualEquiv : LinOrdCat ≌ LinOrdCat where
   functor := dual
   inverse := dual
-  unitIso := NatIso.ofComponents (fun X => Iso.mk <| OrderIso.dualDual X) (fun _ => rfl)
-  counitIso := NatIso.ofComponents (fun X => Iso.mk <| OrderIso.dualDual X) (fun _ => rfl)
+  unitIso := NatIso.ofComponents fun X => Iso.mk <| OrderIso.dualDual X
+  counitIso := NatIso.ofComponents fun X => Iso.mk <| OrderIso.dualDual X
 set_option linter.uppercaseLean3 false in
 #align LinOrd.dual_equiv LinOrdCat.dualEquiv

e8ac6315

feat: port Order.Category.LinOrd (#3281)

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

e54ba225

`order.category.LinOrd` ⟷ `Mathlib.Order.Category.LinOrd`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 121

order.category.LinOrd ⟷ Mathlib.Order.Category.LinOrd

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 121

`order.category.LinOrd` ⟷ `Mathlib.Order.Category.LinOrd`