File: Mathlib/Order/Category/NonemptyFinLinOrd.lean

full_name: NonemptyFiniteLinearOrder
code: /-- A typeclass for nonempty finite linear orders. -/
class NonemptyFiniteLinearOrder (α : Type*) extends Fintype α, LinearOrder α where
  Nonempty : Nonempty α := by infer_instance
goal: Type u_1

full_name: NonemptyFiniteLinearOrder.Nonempty
code: /-- A typeclass for nonempty finite linear orders. -/
class NonemptyFiniteLinearOrder (α : Type*) extends Fintype α, LinearOrder α where
  Nonempty : Nonempty α := by infer_instance
goal: Nonempty α

full_name: NonemptyFiniteLinearOrder.toBoundedOrder
code: instance (priority := 100) NonemptyFiniteLinearOrder.toBoundedOrder (α : Type*)
  [NonemptyFiniteLinearOrder α] : BoundedOrder α 
goal: BoundedOrder α

full_name: PUnit.nonemptyFiniteLinearOrder
code: instance PUnit.nonemptyFiniteLinearOrder : NonemptyFiniteLinearOrder PUnit 
goal: NonemptyFiniteLinearOrder PUnit.{u_1 + 1}

full_name: Fin.nonemptyFiniteLinearOrder
code: instance Fin.nonemptyFiniteLinearOrder (n : ℕ) : NonemptyFiniteLinearOrder (Fin (n + 1)) 
goal: NonemptyFiniteLinearOrder (Fin (n + 1))

full_name: ULift.nonemptyFiniteLinearOrder
code: instance ULift.nonemptyFiniteLinearOrder (α : Type u) [NonemptyFiniteLinearOrder α] :
    NonemptyFiniteLinearOrder (ULift.{v} α) 
goal: NonemptyFiniteLinearOrder (ULift.{v, u} α)

full_name: instNonemptyFiniteLinearOrderOrderDual
code: instance (α : Type*) [NonemptyFiniteLinearOrder α] : NonemptyFiniteLinearOrder αᵒᵈ 
goal: NonemptyFiniteLinearOrder αᵒᵈ

full_name: NonemptyFinLinOrd
code: /-- The category of nonempty finite linear orders. -/
def NonemptyFinLinOrd 
goal: Type (u_1 + 1)

full_name: NonemptyFinLinOrd.instParentProjectionLinearOrderNonemptyFiniteLinearOrderToLinearOrder
code: instance : BundledHom.ParentProjection @NonemptyFiniteLinearOrder.toLinearOrder 
goal: CategoryTheory.BundledHom.ParentProjection @NonemptyFiniteLinearOrder.toLinearOrder

full_name: NonemptyFinLinOrd.instConcreteCategory
code: instance : ConcreteCategory NonemptyFinLinOrd 
goal: CategoryTheory.ConcreteCategory NonemptyFinLinOrd

full_name: NonemptyFinLinOrd.instCoeSortType
code: instance : CoeSort NonemptyFinLinOrd Type* 
goal: CoeSort NonemptyFinLinOrd (Type u_1)

full_name: NonemptyFinLinOrd.of
code: /-- Construct a bundled `NonemptyFinLinOrd` from the underlying type and typeclass. -/
def of (α : Type*) [NonemptyFiniteLinearOrder α] : NonemptyFinLinOrd 
goal: NonemptyFinLinOrd

full_name: NonemptyFinLinOrd.coe_of
code: @[simp]
theorem coe_of (α : Type*) [NonemptyFiniteLinearOrder α] : ↥(of α) = α 
goal: ↑(NonemptyFinLinOrd.of α) = α

full_name: NonemptyFinLinOrd.instInhabited
code: instance : Inhabited NonemptyFinLinOrd 
goal: Inhabited NonemptyFinLinOrd

full_name: NonemptyFinLinOrd.instNonemptyFiniteLinearOrderα
code: instance (α : NonemptyFinLinOrd) : NonemptyFiniteLinearOrder α 
goal: NonemptyFiniteLinearOrder ↑α

full_name: NonemptyFinLinOrd.hasForgetToLinOrd
code: instance hasForgetToLinOrd : HasForget₂ NonemptyFinLinOrd LinOrd 
goal: CategoryTheory.HasForget₂ NonemptyFinLinOrd LinOrd

full_name: NonemptyFinLinOrd.hasForgetToFinPartOrd
code: instance hasForgetToFinPartOrd : HasForget₂ NonemptyFinLinOrd FinPartOrd 
goal: CategoryTheory.HasForget₂ NonemptyFinLinOrd FinPartOrd

full_name: NonemptyFinLinOrd.Iso.mk_inv
code: /-- Constructs an equivalence between nonempty finite linear orders from an order isomorphism
between them. -/
@[simps]
def Iso.mk {α β : NonemptyFinLinOrd.{u}} (e : α ≃o β) : α ≅ β 
goal: (NonemptyFinLinOrd.Iso.mk e).inv = ↑e.symm

full_name: NonemptyFinLinOrd.Iso.mk_hom
code: /-- Constructs an equivalence between nonempty finite linear orders from an order isomorphism
between them. -/
@[simps]
def Iso.mk {α β : NonemptyFinLinOrd.{u}} (e : α ≃o β) : α ≅ β 
goal: (NonemptyFinLinOrd.Iso.mk e).hom = ↑e

full_name: NonemptyFinLinOrd.Iso.mk
code: /-- Constructs an equivalence between nonempty finite linear orders from an order isomorphism
between them. -/
@[simps]
def Iso.mk {α β : NonemptyFinLinOrd.{u}} (e : α ≃o β) : α ≅ β 
goal: α ≅ β

full_name: NonemptyFinLinOrd.dual
code: /-- `OrderDual` as a functor. -/
@[simps]
def dual : NonemptyFinLinOrd ⥤ NonemptyFinLinOrd 
goal: NonemptyFinLinOrd ⥤ NonemptyFinLinOrd

full_name: NonemptyFinLinOrd.dual_obj
code: /-- `OrderDual` as a functor. -/
@[simps]
def dual : NonemptyFinLinOrd ⥤ NonemptyFinLinOrd 
goal: NonemptyFinLinOrd.dual.obj X = NonemptyFinLinOrd.of (↑X)ᵒᵈ

full_name: NonemptyFinLinOrd.dual_map
code: /-- `OrderDual` as a functor. -/
@[simps]
def dual : NonemptyFinLinOrd ⥤ NonemptyFinLinOrd 
goal: ∀ {X Y : NonemptyFinLinOrd} (a : ↑X →o ↑Y), NonemptyFinLinOrd.dual.map a = OrderHom.dual a

full_name: NonemptyFinLinOrd.dualEquiv_functor
code: /-- The equivalence between `NonemptyFinLinOrd` and itself induced by `OrderDual` both ways. -/
@[simps functor inverse]
def dualEquiv : NonemptyFinLinOrd ≌ NonemptyFinLinOrd 
goal: NonemptyFinLinOrd.dualEquiv.functor = NonemptyFinLinOrd.dual

full_name: NonemptyFinLinOrd.dualEquiv
code: /-- The equivalence between `NonemptyFinLinOrd` and itself induced by `OrderDual` both ways. -/
@[simps functor inverse]
def dualEquiv : NonemptyFinLinOrd ≌ NonemptyFinLinOrd 
goal: NonemptyFinLinOrd ≌ NonemptyFinLinOrd

full_name: NonemptyFinLinOrd.dualEquiv_inverse
code: /-- The equivalence between `NonemptyFinLinOrd` and itself induced by `OrderDual` both ways. -/
@[simps functor inverse]
def dualEquiv : NonemptyFinLinOrd ≌ NonemptyFinLinOrd 
goal: NonemptyFinLinOrd.dualEquiv.inverse = NonemptyFinLinOrd.dual

full_name: NonemptyFinLinOrd.instFunLikeHomαNonemptyFiniteLinearOrder
code: instance {A B : NonemptyFinLinOrd.{u}} : FunLike (A ⟶ B) A B 
goal: FunLike (A ⟶ B) ↑A ↑B

full_name: NonemptyFinLinOrd.instOrderHomClassHomαNonemptyFiniteLinearOrder
code: instance {A B : NonemptyFinLinOrd.{u}} : OrderHomClass (A ⟶ B) A B 
goal: OrderHomClass (A ⟶ B) ↑A ↑B

full_name: NonemptyFinLinOrd.mono_iff_injective
code: theorem mono_iff_injective {A B : NonemptyFinLinOrd.{u}} (f : A ⟶ B) :
    Mono f ↔ Function.Injective f 
goal: CategoryTheory.Mono f ↔ Function.Injective ⇑f

full_name: NonemptyFinLinOrd.forget_map_apply
code: lemma forget_map_apply {A B : NonemptyFinLinOrd.{u}} (f : A ⟶ B) (a : A) :
    (forget NonemptyFinLinOrd).map f a = (f : OrderHom A B).toFun a 
goal: (CategoryTheory.forget NonemptyFinLinOrd).map f a = f.toFun a

full_name: NonemptyFinLinOrd.epi_iff_surjective
code: theorem epi_iff_surjective {A B : NonemptyFinLinOrd.{u}} (f : A ⟶ B) :
    Epi f ↔ Function.Surjective f 
goal: CategoryTheory.Epi f ↔ Function.Surjective ⇑f

full_name: NonemptyFinLinOrd.instSplitEpiCategory
code: instance : SplitEpiCategory NonemptyFinLinOrd.{u} 
goal: CategoryTheory.SplitEpiCategory NonemptyFinLinOrd

full_name: NonemptyFinLinOrd.instHasStrongEpiMonoFactorisations
code: instance : HasStrongEpiMonoFactorisations NonemptyFinLinOrd.{u} 
goal: CategoryTheory.Limits.HasStrongEpiMonoFactorisations NonemptyFinLinOrd

full_name: nonemptyFinLinOrd_dual_comp_forget_to_linOrd
code: theorem nonemptyFinLinOrd_dual_comp_forget_to_linOrd :
    NonemptyFinLinOrd.dual ⋙ forget₂ NonemptyFinLinOrd LinOrd =
      forget₂ NonemptyFinLinOrd LinOrd ⋙ LinOrd.dual 
goal: NonemptyFinLinOrd.dual ⋙ CategoryTheory.forget₂ NonemptyFinLinOrd LinOrd =
  CategoryTheory.forget₂ NonemptyFinLinOrd LinOrd ⋙ LinOrd.dual

full_name: nonemptyFinLinOrdDualCompForgetToFinPartOrd
code: /-- The forgetful functor `NonemptyFinLinOrd ⥤ FinPartOrd` and `OrderDual` commute. -/
def nonemptyFinLinOrdDualCompForgetToFinPartOrd :
    NonemptyFinLinOrd.dual ⋙ forget₂ NonemptyFinLinOrd FinPartOrd ≅
      forget₂ NonemptyFinLinOrd FinPartOrd ⋙ FinPartOrd.dual 
goal: NonemptyFinLinOrd.dual ⋙ CategoryTheory.forget₂ NonemptyFinLinOrd FinPartOrd ≅
  CategoryTheory.forget₂ NonemptyFinLinOrd FinPartOrd ⋙ FinPartOrd.dual