Category of linear orders

This defines LinOrd, the category of linear orders with monotone maps.

structure LinOrd.Hom (X Y : LinOrd) : Type u

The type of morphisms in LinOrd R.

• hom' : ↑X →o ↑Y

  The underlying OrderHom.

theorem LinOrd.Hom.ext {X Y : LinOrd} {x y : X.Hom Y} (hom' : x.hom' = y.hom') : x = y

theorem LinOrd.Hom.ext_iff {X Y : LinOrd} {x y : X.Hom Y} : x = y ↔ x.hom' = y.hom'

instance LinOrd.instCategory : CategoryTheory.Category.{u, u + 1} LinOrd

instance LinOrd.instConcreteCategoryOrderHomCarrier : CategoryTheory.ConcreteCategory LinOrd fun (x1 x2 : LinOrd) => ↑x1 →o ↑x2

@[reducible, inline]

abbrev LinOrd.Hom.hom {X Y : LinOrd} (f : X.Hom Y) : ↑X →o ↑Y

Turn a morphism in LinOrd back into a OrderHom.

@[reducible, inline]

abbrev LinOrd.ofHom {X Y : Type u} [LinearOrder X] [LinearOrder Y] (f : X →o Y) : { carrier := X, str := inst✝ } ⟶ { carrier := Y, str := inst✝¹ }

Typecheck a OrderHom as a morphism in LinOrd.

def LinOrd.Hom.Simps.hom (X Y : LinOrd) (f : X.Hom Y) : ↑X →o ↑Y

Use the ConcreteCategory.hom projection for @[simps] lemmas.

The results below duplicate the ConcreteCategory simp lemmas, but we can keep them for dsimp.

@[simp]

theorem LinOrd.coe_id {X : LinOrd} : ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) = id

@[simp]

theorem LinOrd.coe_comp {X Y Z : LinOrd} {f : X ⟶ Y} {g : Y ⟶ Z} : ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) = ⇑(CategoryTheory.ConcreteCategory.hom g) ∘ ⇑(CategoryTheory.ConcreteCategory.hom f)

@[simp]

theorem LinOrd.forget_map {X Y : LinOrd} (f : X ⟶ Y) : (CategoryTheory.forget LinOrd).map f = ⇑(CategoryTheory.ConcreteCategory.hom f)

theorem LinOrd.ext {X Y : LinOrd} {f g : X ⟶ Y} (w : ∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x) : f = g

theorem LinOrd.ext_iff {X Y : LinOrd} {f g : X ⟶ Y} : f = g ↔ ∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x

theorem LinOrd.coe_of (X : Type u) [LinearOrder X] : ↑{ carrier := X, str := inst✝ } = X

@[simp]

theorem LinOrd.hom_id {X : LinOrd} : Hom.hom (CategoryTheory.CategoryStruct.id X) = OrderHom.id

theorem LinOrd.id_apply (X : LinOrd) (x : ↑X) : (CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) x = x

@[simp]

theorem LinOrd.hom_comp {X Y Z : LinOrd} (f : X ⟶ Y) (g : Y ⟶ Z) : Hom.hom (CategoryTheory.CategoryStruct.comp f g) = (Hom.hom g).comp (Hom.hom f)

theorem LinOrd.comp_apply {X Y Z : LinOrd} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X) : (CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) x = (CategoryTheory.ConcreteCategory.hom g) ((CategoryTheory.ConcreteCategory.hom f) x)

theorem LinOrd.hom_ext {X Y : LinOrd} {f g : X ⟶ Y} (hf : Hom.hom f = Hom.hom g) : f = g

theorem LinOrd.hom_ext_iff {X Y : LinOrd} {f g : X ⟶ Y} : f = g ↔ Hom.hom f = Hom.hom g

@[simp]

theorem LinOrd.hom_ofHom {X Y : Type u} [LinearOrder X] [LinearOrder Y] (f : X →o Y) : Hom.hom (ofHom f) = f

@[simp]

theorem LinOrd.ofHom_hom {X Y : LinOrd} (f : X ⟶ Y) : ofHom (Hom.hom f) = f

@[simp]

theorem LinOrd.ofHom_id {X : Type u} [LinearOrder X] : ofHom OrderHom.id = CategoryTheory.CategoryStruct.id { carrier := X, str := inst✝ }

@[simp]

theorem LinOrd.ofHom_comp {X Y Z : Type u} [LinearOrder X] [LinearOrder Y] [LinearOrder Z] (f : X →o Y) (g : Y →o Z) : ofHom (g.comp f) = CategoryTheory.CategoryStruct.comp (ofHom f) (ofHom g)

theorem LinOrd.ofHom_apply {X Y : Type u} [LinearOrder X] [LinearOrder Y] (f : X →o Y) (x : X) : (CategoryTheory.ConcreteCategory.hom (ofHom f)) x = f x

theorem LinOrd.inv_hom_apply {X Y : LinOrd} (e : X ≅ Y) (x : ↑X) : (CategoryTheory.ConcreteCategory.hom e.inv) ((CategoryTheory.ConcreteCategory.hom e.hom) x) = x

theorem LinOrd.hom_inv_apply {X Y : LinOrd} (e : X ≅ Y) (s : ↑Y) : (CategoryTheory.ConcreteCategory.hom e.hom) ((CategoryTheory.ConcreteCategory.hom e.inv) s) = s

instance LinOrd.instInhabited : Inhabited LinOrd

instance LinOrd.hasForgetToLat : CategoryTheory.HasForget₂ LinOrd Lat

def LinOrd.Iso.mk {α β : LinOrd} (e : ↑α ≃o ↑β) : α ≅ β

Constructs an equivalence between linear orders from an order isomorphism between them.

@[simp]

theorem LinOrd.Iso.mk_inv {α β : LinOrd} (e : ↑α ≃o ↑β) : (mk e).inv = ofHom ↑e.symm

@[simp]

theorem LinOrd.Iso.mk_hom {α β : LinOrd} (e : ↑α ≃o ↑β) : (mk e).hom = ofHom ↑e

def LinOrd.dual : CategoryTheory.Functor LinOrd LinOrd

OrderDual as a functor.

@[simp]

theorem LinOrd.dual_map {X✝ Y✝ : LinOrd} (f : X✝ ⟶ Y✝) : dual.map f = ofHom (OrderHom.dual (Hom.hom f))

def LinOrd.dualEquiv : LinOrd ≌ LinOrd

The equivalence between LinOrd and itself induced by OrderDual both ways.

@[simp]

theorem LinOrd.dualEquiv_inverse : dualEquiv.inverse = dual

@[simp]

theorem LinOrd.dualEquiv_functor : dualEquiv.functor = dual

theorem linOrd_dual_comp_forget_to_Lat : LinOrd.dual.comp (CategoryTheory.forget₂ LinOrd Lat) = (CategoryTheory.forget₂ LinOrd Lat).comp Lat.dual