Documentation

Mathlib.CategoryTheory.Presentable.Basic

Presentable objects #

A functor F : C ⥤ D is κ-accessible (Functor.IsCardinalAccessible) if it commutes with colimits of shape J where J is any κ-filtered category (that is essentially small relative to the universe w such that κ : Cardinal.{w}.). We also introduce another typeclass Functor.IsAccessible saying that there exists a regular cardinal κ such that Functor.IsCardinalAccessible.

An object X of a category is κ-presentable (IsCardinalPresentable) if the functor Hom(X, _) (i.e. coyoneda.obj (op X)) is κ-accessible. Similarly as for accessible functors, we define a type class IsPresentable.

References #

A functor F : C ⥤ D is κ-accessible (with κ a regular cardinal) if it preserves colimits of shape J where J is any κ-filtered category. In the mathematical literature, some assumptions are often made on the categories C or D (e.g. the existence of κ-filtered colimits, see HasCardinalFilteredColimits below), but here we do not make such assumptions.

Instances

    A functor is accessible relative to a universe w if it is κ-accessible for some regular κ : Cardinal.{w}.

    Instances
      @[reducible, inline]

      An object X in a category is κ-presentable (for κ a regular cardinal) when the functor Hom(X, _) preserves colimits indexed by κ-filtered categories.

      Equations
      Instances For
        @[reducible, inline]

        The property of objects that are κ-presentable.

        Equations
        Instances For
          theorem CategoryTheory.IsCardinalPresentable.mk {C : Type u₁} [Category.{v₁, u₁} C] {X : C} {κ : Cardinal.{w}} [Fact κ.IsRegular] (hX : ∀ (J : Type w) [inst : SmallCategory J] [IsCardinalFiltered J κ] (F : Functor J C) (c : Limits.Cocone F) (x : Limits.IsColimit c), (∀ (g : X ⟶ c.pt), ∃ (j : J) (f : X ⟶ F.obj j), CategoryStruct.comp f (c.ι.app j) = g) ∧ ∀ (j : J) (f₁ f₂ : X ⟶ F.obj j), CategoryStruct.comp f₁ (c.ι.app j) = CategoryStruct.comp f₂ (c.ι.app j) → ∃ (j' : J) (a : j ⟶ j'), CategoryStruct.comp f₁ (F.map a) = CategoryStruct.comp f₂ (F.map a)) :
          theorem CategoryTheory.Limits.exists_hom_of_preservesColimit_coyoneda {C : Type u₁} [Category.{v₁, u₁} C] {J : Type u_1} [Category.{v_1, u_1} J] {D : Functor J C} {c : Cocone D} (hc : IsColimit c) {X : C} [PreservesColimit D (coyoneda.obj (Opposite.op X))] (f : X ⟶ c.pt) :
          ∃ (j : J) (p : X ⟶ D.obj j), CategoryStruct.comp p (c.ι.app j) = f
          theorem CategoryTheory.Limits.exists_hom₂_of_preservesColimit_coyoneda {C : Type u₁} [Category.{v₁, u₁} C] {J : Type u_1} [Category.{v_1, u_1} J] {D : Functor J C} [IsFiltered J] {c : Cocone D} (hc : IsColimit c) {X : C} [PreservesColimit D (coyoneda.obj (Opposite.op X))] (f g : X ⟶ c.pt) :
          ∃ (j : J) (p : X ⟶ D.obj j) (q : X ⟶ D.obj j), CategoryStruct.comp p (c.ι.app j) = f ∧ CategoryStruct.comp q (c.ι.app j) = g
          theorem CategoryTheory.Limits.exists_hom_of_preservesColimit_coyoneda_of_hasCardinalLT {C : Type u₁} [Category.{v₁, u₁} C] (κ : Cardinal.{w}) [Fact κ.IsRegular] {J : Type u_1} [Category.{v_1, u_1} J] {D : Functor J C} [IsCardinalFiltered J κ] {c : Cocone D} (hc : IsColimit c) {X : C} [PreservesColimit D (coyoneda.obj (Opposite.op X))] {ι : Type u_2} (hi : HasCardinalLT ι κ) (f : ι → (X ⟶ c.pt)) :
          ∃ (j : J) (p : ι → (X ⟶ D.obj j)), ∀ (i : ι), CategoryStruct.comp (p i) (c.ι.app j) = f i
          theorem CategoryTheory.Limits.exists_eq_of_preservesColimit_coyoneda {C : Type u₁} [Category.{v₁, u₁} C] {J : Type u_1} [Category.{v_1, u_1} J] {D : Functor J C} [IsFiltered J] {c : Cocone D} (hc : IsColimit c) {X : C} [PreservesColimit D (coyoneda.obj (Opposite.op X))] {i j : J} (f : X ⟶ D.obj i) (g : X ⟶ D.obj j) (h : CategoryStruct.comp f (c.ι.app i) = CategoryStruct.comp g (c.ι.app j)) :
          ∃ (k : J) (u : i ⟶ k) (v : j ⟶ k), CategoryStruct.comp f (D.map u) = CategoryStruct.comp g (D.map v)
          theorem CategoryTheory.Limits.exists_eq_of_preservesColimit_coyoneda_self {C : Type u₁} [Category.{v₁, u₁} C] {J : Type u_1} [Category.{v_1, u_1} J] {D : Functor J C} [IsFiltered J] {c : Cocone D} (hc : IsColimit c) {X : C} [PreservesColimit D (coyoneda.obj (Opposite.op X))] {i : J} (f g : X ⟶ D.obj i) (h : CategoryStruct.comp f (c.ι.app i) = CategoryStruct.comp g (c.ι.app i)) :
          ∃ (j : J) (a : i ⟶ j), CategoryStruct.comp f (D.map a) = CategoryStruct.comp g (D.map a)
          theorem CategoryTheory.Limits.exists_eq_of_preservesColimit_coyoneda_self_of_hasCardinalLT {C : Type u₁} [Category.{v₁, u₁} C] (κ : Cardinal.{w}) [Fact κ.IsRegular] {J : Type u_1} [Category.{v_1, u_1} J] {D : Functor J C} [IsCardinalFiltered J κ] {c : Cocone D} (hc : IsColimit c) {X : C} [PreservesColimit D (coyoneda.obj (Opposite.op X))] {i : J} {ι : Type u_2} (hi : HasCardinalLT ι κ) (f : ι → (X ⟶ D.obj i)) (h : ∀ (k k' : ι), CategoryStruct.comp (f k) (c.ι.app i) = CategoryStruct.comp (f k') (c.ι.app i)) :
          ∃ (j : J) (a : i ⟶ j), ∀ (k k' : ι), CategoryStruct.comp (f k) (D.map a) = CategoryStruct.comp (f k') (D.map a)
          theorem CategoryTheory.Limits.exists_hom_of_preservesColimit_yoneda {C : Type u₁} [Category.{v₁, u₁} C] {J : Type u_1} [Category.{v_1, u_1} J] {D : Functor J C} {c : Cone D} (hc : IsLimit c) {X : C} [PreservesColimit D.op (yoneda.obj X)] (f : c.pt ⟶ X) :
          ∃ (j : J) (p : D.obj j ⟶ X), CategoryStruct.comp (c.π.app j) p = f
          theorem CategoryTheory.Limits.exists_eq_of_preservesColimit_yoneda {C : Type u₁} [Category.{v₁, u₁} C] {J : Type u_1} [Category.{v_1, u_1} J] {D : Functor J C} [IsCofiltered J] {c : Cone D} (hc : IsLimit c) {X : C} [PreservesColimit D.op (yoneda.obj X)] {i j : J} (f : D.obj i ⟶ X) (g : D.obj j ⟶ X) (h : CategoryStruct.comp (c.π.app i) f = CategoryStruct.comp (c.π.app j) g) :
          ∃ (k : J) (u : k ⟶ i) (v : k ⟶ j), CategoryStruct.comp (D.map u) f = CategoryStruct.comp (D.map v) g
          theorem CategoryTheory.Limits.exists_eq_of_preservesColimit_yoneda_self {C : Type u₁} [Category.{v₁, u₁} C] {J : Type u_1} [Category.{v_1, u_1} J] {D : Functor J C} [IsCofiltered J] {c : Cone D} (hc : IsLimit c) {X : C} [PreservesColimit D.op (yoneda.obj X)] {i : J} (f g : D.obj i ⟶ X) (h : CategoryStruct.comp (c.π.app i) f = CategoryStruct.comp (c.π.app i) g) :
          ∃ (j : J) (a : j ⟶ i), CategoryStruct.comp (D.map a) f = CategoryStruct.comp (D.map a) g
          theorem CategoryTheory.IsCardinalPresentable.exists_hom_above_of_isColimit {C : Type u₁} [Category.{v₁, u₁} C] {X : C} (κ : Cardinal.{w}) [Fact κ.IsRegular] {J : Type u_1} [Category.{v_1, u_1} J] [IsCardinalPresentable X κ] [EssentiallySmall.{w, v_1, u_1} J] [IsCardinalFiltered J κ] {F : Functor J C} {c : Limits.Cocone F} (hc : Limits.IsColimit c) (f : X ⟶ c.pt) (j₀ : J) :
          ∃ (j : J) (x : j₀ ⟶ j) (f' : X ⟶ F.obj j), CategoryStruct.comp f' (c.ι.app j) = f

          A variant of IsCardinalPresentable.exists_hom_of_isColimit where one also imposes the index found to be over a given index j₀.

          theorem CategoryTheory.IsCardinalPresentable.exists_hom_of_isColimit_of_hasCardinalLT {C : Type u₁} [Category.{v₁, u₁} C] {X : C} (κ : Cardinal.{w}) [Fact κ.IsRegular] {J : Type u_1} [Category.{v_1, u_1} J] [IsCardinalPresentable X κ] [EssentiallySmall.{w, v_1, u_1} J] [IsCardinalFiltered J κ] {F : Functor J C} {c : Limits.Cocone F} (hc : Limits.IsColimit c) {ι : Type u_2} (hι : HasCardinalLT ι κ) (f : ι → (X ⟶ c.pt)) :
          ∃ (j : J) (f' : ι → (X ⟶ F.obj j)), ∀ (i : ι), CategoryStruct.comp (f' i) (c.ι.app j) = f i
          theorem CategoryTheory.IsCardinalPresentable.exists_eq_of_isColimit {C : Type u₁} [Category.{v₁, u₁} C] {X : C} (κ : Cardinal.{w}) [Fact κ.IsRegular] {J : Type u_1} [Category.{v_1, u_1} J] [IsCardinalPresentable X κ] [EssentiallySmall.{w, v_1, u_1} J] [IsCardinalFiltered J κ] {F : Functor J C} {c : Limits.Cocone F} (hc : Limits.IsColimit c) {i₁ i₂ : J} (f₁ : X ⟶ F.obj i₁) (f₂ : X ⟶ F.obj i₂) (hf : CategoryStruct.comp f₁ (c.ι.app i₁) = CategoryStruct.comp f₂ (c.ι.app i₂)) :
          ∃ (j : J) (u : i₁ ⟶ j) (v : i₂ ⟶ j), CategoryStruct.comp f₁ (F.map u) = CategoryStruct.comp f₂ (F.map v)
          theorem CategoryTheory.IsCardinalPresentable.exists_eq_of_isColimit' {C : Type u₁} [Category.{v₁, u₁} C] {X : C} (κ : Cardinal.{w}) [Fact κ.IsRegular] {J : Type u_1} [Category.{v_1, u_1} J] [IsCardinalPresentable X κ] [EssentiallySmall.{w, v_1, u_1} J] [IsCardinalFiltered J κ] {F : Functor J C} {c : Limits.Cocone F} (hc : Limits.IsColimit c) {i : J} (f₁ f₂ : X ⟶ F.obj i) (hf : CategoryStruct.comp f₁ (c.ι.app i) = CategoryStruct.comp f₂ (c.ι.app i)) :
          ∃ (j : J) (u : i ⟶ j), CategoryStruct.comp f₁ (F.map u) = CategoryStruct.comp f₂ (F.map u)
          theorem CategoryTheory.IsCardinalPresentable.exists_eq_of_isColimit'_of_hasCardinalLT {C : Type u₁} [Category.{v₁, u₁} C] {X : C} (κ : Cardinal.{w}) [Fact κ.IsRegular] {J : Type u_1} [Category.{v_1, u_1} J] [IsCardinalPresentable X κ] [EssentiallySmall.{w, v_1, u_1} J] [IsCardinalFiltered J κ] {F : Functor J C} {c : Limits.Cocone F} (hc : Limits.IsColimit c) {i : J} {ι : Type u_2} (hι : HasCardinalLT ι κ) (f : ι → (X ⟶ F.obj i)) (hf : ∀ (i₀ i₁ : ι), CategoryStruct.comp (f i₀) (c.ι.app i) = CategoryStruct.comp (f i₁) (c.ι.app i)) :
          ∃ (j : J) (u : i ⟶ j), ∀ (i₀ i₁ : ι), CategoryStruct.comp (f i₀) (F.map u) = CategoryStruct.comp (f i₁) (F.map u)
          theorem CategoryTheory.IsCardinalPresentable.exists_of_square {C : Type u₁} [Category.{v₁, u₁} C] (κ : Cardinal.{w}) [Fact κ.IsRegular] {J : Type u_1} [Category.{v_1, u_1} J] [IsCardinalFiltered J κ] [EssentiallySmall.{w, v_1, u_1} J] {F : Functor J C} {c : Limits.Cocone F} (hc : Limits.IsColimit c) {X₀ X₁ : C} [IsCardinalPresentable X₀ κ] [IsCardinalPresentable X₁ κ] (f₀₁ : X₀ ⟶ X₁) (q : X₁ ⟶ c.pt) {j₀ : J} (g : X₀ ⟶ F.obj j₀) (h : CategoryStruct.comp f₀₁ q = CategoryStruct.comp g (c.ι.app j₀)) :
          ∃ (j₁ : J) (u : j₀ ⟶ j₁) (q' : X₁ ⟶ F.obj j₁), CategoryStruct.comp f₀₁ q' = CategoryStruct.comp g (F.map u) ∧ q = CategoryStruct.comp q' (c.ι.app j₁)

          In a category C, given a diagram F : J ⥤ C where J is κ-filtered and a commutative square

           X₀ ------> X₁
           |          |
           | g        | q
           v          v
          F(j₀) --> colim F
          

          where X₁ is κ-presentable, there exists an index j₁ and a commutative diagram

            X₀ -------------> X₁
            |                 |  \
            |                 |   v
            | g            q' |   colimF
            |                 |   ^
            v                 v  /
          F(j₀) ----------> F(j₁)
          
          theorem CategoryTheory.IsCardinalPresentable.exists_commSq_of_isColimit {C : Type u₁} [Category.{v₁, u₁} C] (κ : Cardinal.{w}) [Fact κ.IsRegular] {J : Type u_2} [Category.{v_2, u_2} J] [EssentiallySmall.{w, v_2, u_2} J] [IsCardinalFiltered J κ] {X Y : Functor J C} (f : X ⟶ Y) {c₁ : Limits.Cocone X} {c₂ : Limits.Cocone Y} (hc₁ : Limits.IsColimit c₁) (hc₂ : Limits.IsColimit c₂) (f' : c₁.pt ⟶ c₂.pt) (hf' : ∀ (j : J), CategoryStruct.comp (c₁.ι.app j) f' = CategoryStruct.comp (f.app j) (c₂.ι.app j)) ⦃X' Y' : C⦄ ⦃t : X' ⟶ Y'⦄ ⦃l : X' ⟶ c₁.pt⦄ ⦃r : Y' ⟶ c₂.pt⦄ [IsCardinalPresentable X' κ] [IsCardinalPresentable Y' κ] (sq : CommSq t l r f') :
          ∃ (j : J) (l' : X' ⟶ X.obj j) (r' : Y' ⟶ Y.obj j), CategoryStruct.comp l' (c₁.ι.app j) = l ∧ CategoryStruct.comp r' (c₂.ι.app j) = r ∧ CommSq t l' r' (f.app j)

          Given a commutative square where both objects on the top are κ-presentable and the bottom map is a colimit of a natural transformation f : X ⟶ Y between functors in J ⥤ C where J is κ-filtered, the commutative square can be refined by replacing the colimit map in the bottom by a morphism f.app j : X.obj j ⟶ Y.obj j for a big enough j.

          @[reducible, inline]

          An object of a category is presentable relative to a universe w if it is κ-presentable for some regular κ : Cardinal.{w}.

          Equations
          Instances For

            A category has κ-filtered colimits if it has colimits of shape J for any κ-filtered category J.

            Instances