File: Mathlib/CategoryTheory/Skeletal.lean

full_name: CategoryTheory.Skeletal
code: /-- A category is skeletal if isomorphic objects are equal. -/
def Skeletal : Prop 
goal: Prop

full_name: CategoryTheory.IsSkeletonOf
code: /-- `IsSkeletonOf C D F` says that `F : D ⥤ C` exhibits `D` as a skeletal full subcategory of `C`,
in particular `F` is a (strong) equivalence and `D` is skeletal.
-/
structure IsSkeletonOf (F : D ⥤ C) : Prop where
  /-- The category `D` has isomorphic objects equal -/
  skel : Skeletal D
  /-- The functor `F` is an equivalence -/
  eqv : F.IsEquivalence := by infer_instance
goal: Prop

full_name: CategoryTheory.IsSkeletonOf.skel
code: /-- `IsSkeletonOf C D F` says that `F : D ⥤ C` exhibits `D` as a skeletal full subcategory of `C`,
in particular `F` is a (strong) equivalence and `D` is skeletal.
-/
structure IsSkeletonOf (F : D ⥤ C) : Prop where
  /-- The category `D` has isomorphic objects equal -/
  skel : Skeletal D
  /-- The functor `F` is an equivalence -/
  eqv : F.IsEquivalence := by infer_instance
goal: CategoryTheory.Skeletal D

full_name: CategoryTheory.IsSkeletonOf.eqv
code: /-- `IsSkeletonOf C D F` says that `F : D ⥤ C` exhibits `D` as a skeletal full subcategory of `C`,
in particular `F` is a (strong) equivalence and `D` is skeletal.
-/
structure IsSkeletonOf (F : D ⥤ C) : Prop where
  /-- The category `D` has isomorphic objects equal -/
  skel : Skeletal D
  /-- The functor `F` is an equivalence -/
  eqv : F.IsEquivalence := by infer_instance
goal: F.IsEquivalence

full_name: CategoryTheory.Functor.eq_of_iso
code: /-- If `C` is thin and skeletal, then any naturally isomorphic functors to `C` are equal. -/
theorem Functor.eq_of_iso {F₁ F₂ : D ⥤ C} [Quiver.IsThin C] (hC : Skeletal C) (hF : F₁ ≅ F₂) :
    F₁ = F₂ 
goal: F₁ = F₂

full_name: CategoryTheory.functor_skeletal
code: /-- If `C` is thin and skeletal, `D ⥤ C` is skeletal.
`CategoryTheory.functor_thin` shows it is thin also.
-/
theorem functor_skeletal [Quiver.IsThin C] (hC : Skeletal C) : Skeletal (D ⥤ C) 
goal: CategoryTheory.Skeletal (CategoryTheory.Functor D C)

full_name: CategoryTheory.Skeleton
code: /-- Construct the skeleton category as the induced category on the isomorphism classes, and derive
its category structure.
-/
def Skeleton : Type u₁ 
goal: Type u₁

full_name: CategoryTheory.instInhabitedSkeleton
code: instance [Inhabited C] : Inhabited (Skeleton C) 
goal: Inhabited (CategoryTheory.Skeleton C)

full_name: CategoryTheory.instCategorySkeleton
code: noncomputable instance : Category (Skeleton C) 
goal: CategoryTheory.Category.{v₁, u₁} (CategoryTheory.Skeleton C)

full_name: CategoryTheory.fromSkeleton
code: /-- The functor from the skeleton of `C` to `C`. -/
@[simps!]
noncomputable def fromSkeleton : Skeleton C ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Skeleton C) C

full_name: CategoryTheory.fromSkeleton_map
code: /-- The functor from the skeleton of `C` to `C`. -/
@[simps!]
noncomputable def fromSkeleton : Skeleton C ⥤ C 
goal: ∀ {X Y : CategoryTheory.InducedCategory C Quotient.out} (f : X ⟶ Y), (CategoryTheory.fromSkeleton C).map f = f

full_name: CategoryTheory.fromSkeleton_obj
code: /-- The functor from the skeleton of `C` to `C`. -/
@[simps!]
noncomputable def fromSkeleton : Skeleton C ⥤ C 
goal: ∀ (a : Quotient (CategoryTheory.isIsomorphicSetoid C)), (CategoryTheory.fromSkeleton C).obj a = a.out

full_name: CategoryTheory.instFullSkeletonFromSkeleton
code: noncomputable instance : (fromSkeleton C).Full 
goal: (CategoryTheory.fromSkeleton C).Full

full_name: CategoryTheory.instFaithfulSkeletonFromSkeleton
code: noncomputable instance : (fromSkeleton C).Faithful 
goal: (CategoryTheory.fromSkeleton C).Faithful

full_name: CategoryTheory.instEssSurjSkeletonFromSkeleton
code: instance : (fromSkeleton C).EssSurj 
goal: (CategoryTheory.fromSkeleton C).EssSurj

full_name: CategoryTheory.fromSkeleton.isEquivalence
code: noncomputable instance fromSkeleton.isEquivalence : (fromSkeleton C).IsEquivalence 
goal: (CategoryTheory.fromSkeleton C).IsEquivalence

full_name: CategoryTheory.skeletonEquivalence
code: /-- The equivalence between the skeleton and the category itself. -/
noncomputable def skeletonEquivalence : Skeleton C ≌ C 
goal: CategoryTheory.Skeleton C ≌ C

full_name: CategoryTheory.skeleton_skeletal
code: theorem skeleton_skeletal : Skeletal (Skeleton C) 
goal: CategoryTheory.Skeletal (CategoryTheory.Skeleton C)

full_name: CategoryTheory.skeleton_isSkeleton
code: /-- The `skeleton` of `C` given by choice is a skeleton of `C`. -/
lemma skeleton_isSkeleton : IsSkeletonOf C (Skeleton C) (fromSkeleton C) 
goal: CategoryTheory.IsSkeletonOf C (CategoryTheory.Skeleton C) (CategoryTheory.fromSkeleton C)

full_name: CategoryTheory.Equivalence.skeletonEquiv
code: /-- Two categories which are categorically equivalent have skeletons with equivalent objects.
-/
noncomputable def Equivalence.skeletonEquiv (e : C ≌ D) : Skeleton C ≃ Skeleton D 
goal: CategoryTheory.Skeleton C ≃ CategoryTheory.Skeleton D

full_name: CategoryTheory.ThinSkeleton
code: /-- Construct the skeleton category by taking the quotient of objects. This construction gives a
preorder with nice definitional properties, but is only really appropriate for thin categories.
If your original category is not thin, you probably want to be using `skeleton` instead of this.
-/
def ThinSkeleton : Type u₁ 
goal: Type u₁

full_name: CategoryTheory.inhabitedThinSkeleton
code: instance inhabitedThinSkeleton [Inhabited C] : Inhabited (ThinSkeleton C) 
goal: Inhabited (CategoryTheory.ThinSkeleton C)

full_name: CategoryTheory.ThinSkeleton.preorder
code: instance ThinSkeleton.preorder : Preorder (ThinSkeleton C) 
goal: Preorder (CategoryTheory.ThinSkeleton C)

full_name: CategoryTheory.toThinSkeleton_map
code: /-- The functor from a category to its thin skeleton. -/
@[simps]
def toThinSkeleton : C ⥤ ThinSkeleton C 
goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.toThinSkeleton C).map f = CategoryTheory.homOfLE ⋯

full_name: CategoryTheory.toThinSkeleton
code: /-- The functor from a category to its thin skeleton. -/
@[simps]
def toThinSkeleton : C ⥤ ThinSkeleton C 
goal: CategoryTheory.Functor C (CategoryTheory.ThinSkeleton C)

full_name: CategoryTheory.toThinSkeleton_obj
code: /-- The functor from a category to its thin skeleton. -/
@[simps]
def toThinSkeleton : C ⥤ ThinSkeleton C 
goal: (CategoryTheory.toThinSkeleton C).obj a = Quotient.mk' a

full_name: CategoryTheory.ThinSkeleton.thin
code: /-- The thin skeleton is thin. -/
instance thin : Quiver.IsThin (ThinSkeleton C) 
goal: Quiver.IsThin (CategoryTheory.ThinSkeleton C)

full_name: CategoryTheory.ThinSkeleton.map
code: /-- A functor `C ⥤ D` computably lowers to a functor `ThinSkeleton C ⥤ ThinSkeleton D`. -/
@[simps]
def map (F : C ⥤ D) : ThinSkeleton C ⥤ ThinSkeleton D 
goal: CategoryTheory.Functor (CategoryTheory.ThinSkeleton C) (CategoryTheory.ThinSkeleton D)

full_name: CategoryTheory.ThinSkeleton.map_map
code: /-- A functor `C ⥤ D` computably lowers to a functor `ThinSkeleton C ⥤ ThinSkeleton D`. -/
@[simps]
def map (F : C ⥤ D) : ThinSkeleton C ⥤ ThinSkeleton D 
goal: ∀ (a : X ⟶ Y),
  (CategoryTheory.ThinSkeleton.map F).map a =
    Quotient.recOnSubsingleton₂ (motive := fun x x_1 => (x ⟶ x_1) → (Quotient.map F.obj ⋯ x ⟶ Quotient.map F.obj ⋯ x_1))
      X Y (fun x y k => CategoryTheory.homOfLE ⋯) a

full_name: CategoryTheory.ThinSkeleton.map_obj
code: /-- A functor `C ⥤ D` computably lowers to a functor `ThinSkeleton C ⥤ ThinSkeleton D`. -/
@[simps]
def map (F : C ⥤ D) : ThinSkeleton C ⥤ ThinSkeleton D 
goal: ∀ (a : Quotient (CategoryTheory.isIsomorphicSetoid C)),
  (CategoryTheory.ThinSkeleton.map F).obj a = Quotient.map F.obj ⋯ a

full_name: CategoryTheory.ThinSkeleton.comp_toThinSkeleton
code: theorem comp_toThinSkeleton (F : C ⥤ D) : F ⋙ toThinSkeleton D = toThinSkeleton C ⋙ map F 
goal: F.comp (CategoryTheory.toThinSkeleton D) = (CategoryTheory.toThinSkeleton C).comp (CategoryTheory.ThinSkeleton.map F)

full_name: CategoryTheory.ThinSkeleton.mapNatTrans
code: /-- Given a natural transformation `F₁ ⟶ F₂`, induce a natural transformation `map F₁ ⟶ map F₂`. -/
def mapNatTrans {F₁ F₂ : C ⥤ D} (k : F₁ ⟶ F₂) : map F₁ ⟶ map F₂ 
goal: CategoryTheory.ThinSkeleton.map F₁ ⟶ CategoryTheory.ThinSkeleton.map F₂

full_name: CategoryTheory.ThinSkeleton.map₂ObjMap
code: /-- Given a bifunctor, we descend to a function on objects of `ThinSkeleton` -/
def map₂ObjMap (F : C ⥤ D ⥤ E) : ThinSkeleton C → ThinSkeleton D → ThinSkeleton E 
goal: CategoryTheory.ThinSkeleton C → CategoryTheory.ThinSkeleton D → CategoryTheory.ThinSkeleton E

full_name: CategoryTheory.ThinSkeleton.map₂Functor
code: /-- For each `x : ThinSkeleton C`, we promote `map₂ObjMap F x` to a functor -/
def map₂Functor (F : C ⥤ D ⥤ E) : ThinSkeleton C → ThinSkeleton D ⥤ ThinSkeleton E 
goal: CategoryTheory.ThinSkeleton C → CategoryTheory.Functor (CategoryTheory.ThinSkeleton D) (CategoryTheory.ThinSkeleton E)

full_name: CategoryTheory.ThinSkeleton.map₂NatTrans
code: /-- This provides natural transformations `map₂Functor F x₁ ⟶ map₂Functor F x₂` given
`x₁ ⟶ x₂` -/
def map₂NatTrans (F : C ⥤ D ⥤ E) : {x₁ x₂ : ThinSkeleton C} → (x₁ ⟶ x₂) →
    (map₂Functor F x₁ ⟶ map₂Functor F x₂) 
goal: (x₁ ⟶ x₂) → (CategoryTheory.ThinSkeleton.map₂Functor F x₁ ⟶ CategoryTheory.ThinSkeleton.map₂Functor F x₂)

full_name: CategoryTheory.ThinSkeleton.map₂
code: /-- A functor `C ⥤ D ⥤ E` computably lowers to a functor
`ThinSkeleton C ⥤ ThinSkeleton D ⥤ ThinSkeleton E` -/
@[simps]
def map₂ (F : C ⥤ D ⥤ E) : ThinSkeleton C ⥤ ThinSkeleton D ⥤ ThinSkeleton E 
goal: CategoryTheory.Functor (CategoryTheory.ThinSkeleton C)
  (CategoryTheory.Functor (CategoryTheory.ThinSkeleton D) (CategoryTheory.ThinSkeleton E))

full_name: CategoryTheory.ThinSkeleton.map₂_obj
code: /-- A functor `C ⥤ D ⥤ E` computably lowers to a functor
`ThinSkeleton C ⥤ ThinSkeleton D ⥤ ThinSkeleton E` -/
@[simps]
def map₂ (F : C ⥤ D ⥤ E) : ThinSkeleton C ⥤ ThinSkeleton D ⥤ ThinSkeleton E 
goal: ∀ (a : CategoryTheory.ThinSkeleton C),
  (CategoryTheory.ThinSkeleton.map₂ F).obj a = CategoryTheory.ThinSkeleton.map₂Functor F a

full_name: CategoryTheory.ThinSkeleton.map₂_map
code: /-- A functor `C ⥤ D ⥤ E` computably lowers to a functor
`ThinSkeleton C ⥤ ThinSkeleton D ⥤ ThinSkeleton E` -/
@[simps]
def map₂ (F : C ⥤ D ⥤ E) : ThinSkeleton C ⥤ ThinSkeleton D ⥤ ThinSkeleton E 
goal: ∀ {X Y : CategoryTheory.ThinSkeleton C} (a : X ⟶ Y),
  (CategoryTheory.ThinSkeleton.map₂ F).map a = CategoryTheory.ThinSkeleton.map₂NatTrans F a

full_name: CategoryTheory.ThinSkeleton.toThinSkeleton_faithful
code: instance toThinSkeleton_faithful : (toThinSkeleton C).Faithful 
goal: (CategoryTheory.toThinSkeleton C).Faithful

full_name: CategoryTheory.ThinSkeleton.fromThinSkeleton_map
code: /-- Use `Quotient.out` to create a functor out of the thin skeleton. -/
@[simps]
noncomputable def fromThinSkeleton : ThinSkeleton C ⥤ C 
goal: ∀ (a : x ⟶ y),
  (CategoryTheory.ThinSkeleton.fromThinSkeleton C).map a =
    Quotient.recOnSubsingleton₂ (motive := fun x x_1 => (x ⟶ x_1) → (Quotient.out x ⟶ Quotient.out x_1)) x y
      (fun X Y f =>
        CategoryTheory.CategoryStruct.comp (Nonempty.some ⋯).hom
          (CategoryTheory.CategoryStruct.comp (Nonempty.some ⋯) (Nonempty.some ⋯).inv))
      a

full_name: CategoryTheory.ThinSkeleton.fromThinSkeleton
code: /-- Use `Quotient.out` to create a functor out of the thin skeleton. -/
@[simps]
noncomputable def fromThinSkeleton : ThinSkeleton C ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.ThinSkeleton C) C

full_name: CategoryTheory.ThinSkeleton.fromThinSkeleton_obj
code: /-- Use `Quotient.out` to create a functor out of the thin skeleton. -/
@[simps]
noncomputable def fromThinSkeleton : ThinSkeleton C ⥤ C 
goal: ∀ (a : Quotient (CategoryTheory.isIsomorphicSetoid C)), (CategoryTheory.ThinSkeleton.fromThinSkeleton C).obj a = a.out

full_name: CategoryTheory.ThinSkeleton.equivalence
code: /-- The equivalence between the thin skeleton and the category itself. -/
noncomputable def equivalence : ThinSkeleton C ≌ C 
goal: CategoryTheory.ThinSkeleton C ≌ C

full_name: CategoryTheory.ThinSkeleton.fromThinSkeleton_isEquivalence
code: noncomputable instance fromThinSkeleton_isEquivalence : (fromThinSkeleton C).IsEquivalence 
goal: (CategoryTheory.ThinSkeleton.fromThinSkeleton C).IsEquivalence

full_name: CategoryTheory.ThinSkeleton.equiv_of_both_ways
code: theorem equiv_of_both_ways {X Y : C} (f : X ⟶ Y) (g : Y ⟶ X) : X ≈ Y 
goal: X ≈ Y

full_name: CategoryTheory.ThinSkeleton.thinSkeletonPartialOrder
code: instance thinSkeletonPartialOrder : PartialOrder (ThinSkeleton C) 
goal: PartialOrder (CategoryTheory.ThinSkeleton C)

full_name: CategoryTheory.ThinSkeleton.skeletal
code: theorem skeletal : Skeletal (ThinSkeleton C) 
goal: CategoryTheory.Skeletal (CategoryTheory.ThinSkeleton C)

full_name: CategoryTheory.ThinSkeleton.map_comp_eq
code: theorem map_comp_eq (F : E ⥤ D) (G : D ⥤ C) : map (F ⋙ G) = map F ⋙ map G 
goal: CategoryTheory.ThinSkeleton.map (F.comp G) =
  (CategoryTheory.ThinSkeleton.map F).comp (CategoryTheory.ThinSkeleton.map G)

full_name: CategoryTheory.ThinSkeleton.map_id_eq
code: theorem map_id_eq : map (𝟭 C) = 𝟭 (ThinSkeleton C) 
goal: CategoryTheory.ThinSkeleton.map (CategoryTheory.Functor.id C) =
  CategoryTheory.Functor.id (CategoryTheory.ThinSkeleton C)

full_name: CategoryTheory.ThinSkeleton.map_iso_eq
code: theorem map_iso_eq {F₁ F₂ : D ⥤ C} (h : F₁ ≅ F₂) : map F₁ = map F₂ 
goal: CategoryTheory.ThinSkeleton.map F₁ = CategoryTheory.ThinSkeleton.map F₂

full_name: CategoryTheory.ThinSkeleton.thinSkeleton_isSkeleton
code: /-- `fromThinSkeleton C` exhibits the thin skeleton as a skeleton. -/
lemma thinSkeleton_isSkeleton : IsSkeletonOf C (ThinSkeleton C) (fromThinSkeleton C) 
goal: CategoryTheory.IsSkeletonOf C (CategoryTheory.ThinSkeleton C) (CategoryTheory.ThinSkeleton.fromThinSkeleton C)

full_name: CategoryTheory.ThinSkeleton.isSkeletonOfInhabited
code: instance isSkeletonOfInhabited :
    Inhabited (IsSkeletonOf C (ThinSkeleton C) (fromThinSkeleton C)) 
goal: Inhabited
  (CategoryTheory.IsSkeletonOf C (CategoryTheory.ThinSkeleton C) (CategoryTheory.ThinSkeleton.fromThinSkeleton C))

full_name: CategoryTheory.ThinSkeleton.lowerAdjunction
code: /-- An adjunction between thin categories gives an adjunction between their thin skeletons. -/
def lowerAdjunction (R : D ⥤ C) (L : C ⥤ D) (h : L ⊣ R) : ThinSkeleton.map L ⊣ ThinSkeleton.map R 
goal: CategoryTheory.ThinSkeleton.map L ⊣ CategoryTheory.ThinSkeleton.map R

full_name: CategoryTheory.Equivalence.thinSkeletonOrderIso
code: /--
When `e : C ≌ α` is a categorical equivalence from a thin category `C` to some partial order `α`,
the `ThinSkeleton C` is order isomorphic to `α`.
-/
noncomputable def Equivalence.thinSkeletonOrderIso [Quiver.IsThin C] (e : C ≌ α) :
    ThinSkeleton C ≃o α 
goal: CategoryTheory.ThinSkeleton C ≃o α