File: Mathlib/CategoryTheory/Limits/Indization/IndObject.lean

full_name: CategoryTheory.Limits.IndObjectPresentation.hI
code: /-- The data that witnesses that a presheaf `A` is an ind-object. It consists of a small
    filtered indexing category `I`, a diagram `F : I ⥤ C` and the data for a colimit cocone on
    `F ⋙ yoneda : I ⥤ Cᵒᵖ ⥤ Type v` with cocone point `A`. -/
structure IndObjectPresentation (A : Cᵒᵖ ⥤ Type v) where
  /-- The indexing category of the filtered colimit presentation -/
  I : Type v
  /-- The indexing category of the filtered colimit presentation -/
  [ℐ : SmallCategory I]
  [hI : IsFiltered I]
  /-- The diagram of the filtered colimit presentation -/
  F : I ⥤ C
  /-- Use `IndObjectPresentation.cocone` instead. -/
  ι : F ⋙ yoneda ⟶ (Functor.const I).obj A
  /-- Use `IndObjectPresenation.coconeIsColimit` instead. -/
  isColimit : IsColimit (Cocone.mk A ι)
goal: CategoryTheory.IsFiltered self.I

full_name: CategoryTheory.Limits.IndObjectPresentation
code: /-- The data that witnesses that a presheaf `A` is an ind-object. It consists of a small
    filtered indexing category `I`, a diagram `F : I ⥤ C` and the data for a colimit cocone on
    `F ⋙ yoneda : I ⥤ Cᵒᵖ ⥤ Type v` with cocone point `A`. -/
structure IndObjectPresentation (A : Cᵒᵖ ⥤ Type v) where
  /-- The indexing category of the filtered colimit presentation -/
  I : Type v
  /-- The indexing category of the filtered colimit presentation -/
  [ℐ : SmallCategory I]
  [hI : IsFiltered I]
  /-- The diagram of the filtered colimit presentation -/
  F : I ⥤ C
  /-- Use `IndObjectPresentation.cocone` instead. -/
  ι : F ⋙ yoneda ⟶ (Functor.const I).obj A
  /-- Use `IndObjectPresenation.coconeIsColimit` instead. -/
  isColimit : IsColimit (Cocone.mk A ι)
goal: Type (max u (v + 1))

full_name: CategoryTheory.Limits.IndObjectPresentation.I
code: /-- The data that witnesses that a presheaf `A` is an ind-object. It consists of a small
    filtered indexing category `I`, a diagram `F : I ⥤ C` and the data for a colimit cocone on
    `F ⋙ yoneda : I ⥤ Cᵒᵖ ⥤ Type v` with cocone point `A`. -/
structure IndObjectPresentation (A : Cᵒᵖ ⥤ Type v) where
  /-- The indexing category of the filtered colimit presentation -/
  I : Type v
  /-- The indexing category of the filtered colimit presentation -/
  [ℐ : SmallCategory I]
  [hI : IsFiltered I]
  /-- The diagram of the filtered colimit presentation -/
  F : I ⥤ C
  /-- Use `IndObjectPresentation.cocone` instead. -/
  ι : F ⋙ yoneda ⟶ (Functor.const I).obj A
  /-- Use `IndObjectPresenation.coconeIsColimit` instead. -/
  isColimit : IsColimit (Cocone.mk A ι)
goal: Type v

full_name: CategoryTheory.Limits.IndObjectPresentation.ι
code: /-- The data that witnesses that a presheaf `A` is an ind-object. It consists of a small
    filtered indexing category `I`, a diagram `F : I ⥤ C` and the data for a colimit cocone on
    `F ⋙ yoneda : I ⥤ Cᵒᵖ ⥤ Type v` with cocone point `A`. -/
structure IndObjectPresentation (A : Cᵒᵖ ⥤ Type v) where
  /-- The indexing category of the filtered colimit presentation -/
  I : Type v
  /-- The indexing category of the filtered colimit presentation -/
  [ℐ : SmallCategory I]
  [hI : IsFiltered I]
  /-- The diagram of the filtered colimit presentation -/
  F : I ⥤ C
  /-- Use `IndObjectPresentation.cocone` instead. -/
  ι : F ⋙ yoneda ⟶ (Functor.const I).obj A
  /-- Use `IndObjectPresenation.coconeIsColimit` instead. -/
  isColimit : IsColimit (Cocone.mk A ι)
goal: self.F.comp CategoryTheory.yoneda ⟶ (CategoryTheory.Functor.const self.I).obj A

full_name: CategoryTheory.Limits.IndObjectPresentation.F
code: /-- The data that witnesses that a presheaf `A` is an ind-object. It consists of a small
    filtered indexing category `I`, a diagram `F : I ⥤ C` and the data for a colimit cocone on
    `F ⋙ yoneda : I ⥤ Cᵒᵖ ⥤ Type v` with cocone point `A`. -/
structure IndObjectPresentation (A : Cᵒᵖ ⥤ Type v) where
  /-- The indexing category of the filtered colimit presentation -/
  I : Type v
  /-- The indexing category of the filtered colimit presentation -/
  [ℐ : SmallCategory I]
  [hI : IsFiltered I]
  /-- The diagram of the filtered colimit presentation -/
  F : I ⥤ C
  /-- Use `IndObjectPresentation.cocone` instead. -/
  ι : F ⋙ yoneda ⟶ (Functor.const I).obj A
  /-- Use `IndObjectPresenation.coconeIsColimit` instead. -/
  isColimit : IsColimit (Cocone.mk A ι)
goal: CategoryTheory.Functor self.I C

full_name: CategoryTheory.Limits.IndObjectPresentation.ℐ
code: /-- The data that witnesses that a presheaf `A` is an ind-object. It consists of a small
    filtered indexing category `I`, a diagram `F : I ⥤ C` and the data for a colimit cocone on
    `F ⋙ yoneda : I ⥤ Cᵒᵖ ⥤ Type v` with cocone point `A`. -/
structure IndObjectPresentation (A : Cᵒᵖ ⥤ Type v) where
  /-- The indexing category of the filtered colimit presentation -/
  I : Type v
  /-- The indexing category of the filtered colimit presentation -/
  [ℐ : SmallCategory I]
  [hI : IsFiltered I]
  /-- The diagram of the filtered colimit presentation -/
  F : I ⥤ C
  /-- Use `IndObjectPresentation.cocone` instead. -/
  ι : F ⋙ yoneda ⟶ (Functor.const I).obj A
  /-- Use `IndObjectPresenation.coconeIsColimit` instead. -/
  isColimit : IsColimit (Cocone.mk A ι)
goal: CategoryTheory.SmallCategory self.I

full_name: CategoryTheory.Limits.IndObjectPresentation.isColimit
code: /-- The data that witnesses that a presheaf `A` is an ind-object. It consists of a small
    filtered indexing category `I`, a diagram `F : I ⥤ C` and the data for a colimit cocone on
    `F ⋙ yoneda : I ⥤ Cᵒᵖ ⥤ Type v` with cocone point `A`. -/
structure IndObjectPresentation (A : Cᵒᵖ ⥤ Type v) where
  /-- The indexing category of the filtered colimit presentation -/
  I : Type v
  /-- The indexing category of the filtered colimit presentation -/
  [ℐ : SmallCategory I]
  [hI : IsFiltered I]
  /-- The diagram of the filtered colimit presentation -/
  F : I ⥤ C
  /-- Use `IndObjectPresentation.cocone` instead. -/
  ι : F ⋙ yoneda ⟶ (Functor.const I).obj A
  /-- Use `IndObjectPresenation.coconeIsColimit` instead. -/
  isColimit : IsColimit (Cocone.mk A ι)
goal: CategoryTheory.Limits.IsColimit { pt := A, ι := self.ι }

full_name: CategoryTheory.Limits.IndObjectPresentation.ofCocone_I
code: /-- Alternative constructor for `IndObjectPresentation` taking a cocone instead of its defining
    natural transformation. -/
@[simps]
def ofCocone {I : Type v} [SmallCategory I] [IsFiltered I] {F : I ⥤ C}
    (c : Cocone (F ⋙ yoneda)) (hc : IsColimit c) : IndObjectPresentation c.pt 
goal: (CategoryTheory.Limits.IndObjectPresentation.ofCocone c hc).I = I

full_name: CategoryTheory.Limits.IndObjectPresentation.ofCocone_ℐ
code: /-- Alternative constructor for `IndObjectPresentation` taking a cocone instead of its defining
    natural transformation. -/
@[simps]
def ofCocone {I : Type v} [SmallCategory I] [IsFiltered I] {F : I ⥤ C}
    (c : Cocone (F ⋙ yoneda)) (hc : IsColimit c) : IndObjectPresentation c.pt 
goal: (CategoryTheory.Limits.IndObjectPresentation.ofCocone c hc).ℐ = inst✝

full_name: CategoryTheory.Limits.IndObjectPresentation.ofCocone_ι
code: /-- Alternative constructor for `IndObjectPresentation` taking a cocone instead of its defining
    natural transformation. -/
@[simps]
def ofCocone {I : Type v} [SmallCategory I] [IsFiltered I] {F : I ⥤ C}
    (c : Cocone (F ⋙ yoneda)) (hc : IsColimit c) : IndObjectPresentation c.pt 
goal: (CategoryTheory.Limits.IndObjectPresentation.ofCocone c hc).ι = c.ι

full_name: CategoryTheory.Limits.IndObjectPresentation.ofCocone_F
code: /-- Alternative constructor for `IndObjectPresentation` taking a cocone instead of its defining
    natural transformation. -/
@[simps]
def ofCocone {I : Type v} [SmallCategory I] [IsFiltered I] {F : I ⥤ C}
    (c : Cocone (F ⋙ yoneda)) (hc : IsColimit c) : IndObjectPresentation c.pt 
goal: (CategoryTheory.Limits.IndObjectPresentation.ofCocone c hc).F = F

full_name: CategoryTheory.Limits.IndObjectPresentation.ofCocone_isColimit
code: /-- Alternative constructor for `IndObjectPresentation` taking a cocone instead of its defining
    natural transformation. -/
@[simps]
def ofCocone {I : Type v} [SmallCategory I] [IsFiltered I] {F : I ⥤ C}
    (c : Cocone (F ⋙ yoneda)) (hc : IsColimit c) : IndObjectPresentation c.pt 
goal: (CategoryTheory.Limits.IndObjectPresentation.ofCocone c hc).isColimit = hc

full_name: CategoryTheory.Limits.IndObjectPresentation.ofCocone
code: /-- Alternative constructor for `IndObjectPresentation` taking a cocone instead of its defining
    natural transformation. -/
@[simps]
def ofCocone {I : Type v} [SmallCategory I] [IsFiltered I] {F : I ⥤ C}
    (c : Cocone (F ⋙ yoneda)) (hc : IsColimit c) : IndObjectPresentation c.pt 
goal: CategoryTheory.Limits.IndObjectPresentation c.pt

full_name: CategoryTheory.Limits.IndObjectPresentation.instSmallCategoryI
code: instance : SmallCategory P.I 
goal: CategoryTheory.SmallCategory P.I

full_name: CategoryTheory.Limits.IndObjectPresentation.instIsFilteredI
code: instance : IsFiltered P.I 
goal: CategoryTheory.IsFiltered P.I

full_name: CategoryTheory.Limits.IndObjectPresentation.cocone_pt
code: /-- The (colimit) cocone with cocone point `A`. -/
@[simps pt]
def cocone : Cocone (P.F ⋙ yoneda) 
goal: P.cocone.pt = A

full_name: CategoryTheory.Limits.IndObjectPresentation.cocone
code: /-- The (colimit) cocone with cocone point `A`. -/
@[simps pt]
def cocone : Cocone (P.F ⋙ yoneda) 
goal: CategoryTheory.Limits.Cocone (P.F.comp CategoryTheory.yoneda)

full_name: CategoryTheory.Limits.IndObjectPresentation.coconeIsColimit
code: /-- `P.cocone` is a colimit cocone. -/
def coconeIsColimit : IsColimit P.cocone 
goal: CategoryTheory.Limits.IsColimit P.cocone

full_name: CategoryTheory.Limits.IndObjectPresentation.extend_F
code: /-- If `A` and `B` are isomorphic, then an ind-object presentation of `A` can be extended to an
    ind-object presentation of `B`. -/
@[simps!]
noncomputable def extend {A B : Cᵒᵖ ⥤ Type v} (P : IndObjectPresentation A) (η : A ⟶ B) [IsIso η] :
    IndObjectPresentation B 
goal: (P.extend η).F = P.F

full_name: CategoryTheory.Limits.IndObjectPresentation.extend_ι_app_app
code: /-- If `A` and `B` are isomorphic, then an ind-object presentation of `A` can be extended to an
    ind-object presentation of `B`. -/
@[simps!]
noncomputable def extend {A B : Cᵒᵖ ⥤ Type v} (P : IndObjectPresentation A) (η : A ⟶ B) [IsIso η] :
    IndObjectPresentation B 
goal: ∀ (X_1 : Cᵒᵖ) (a : ((Opposite.unop (Opposite.op (P.F.comp CategoryTheory.yoneda))).obj X).obj X_1),
  ((P.extend η).ι.app X).app X_1 a = η.app X_1 ((P.cocone.ι.app X).app X_1 a)

full_name: CategoryTheory.Limits.IndObjectPresentation.extend_ℐ
code: /-- If `A` and `B` are isomorphic, then an ind-object presentation of `A` can be extended to an
    ind-object presentation of `B`. -/
@[simps!]
noncomputable def extend {A B : Cᵒᵖ ⥤ Type v} (P : IndObjectPresentation A) (η : A ⟶ B) [IsIso η] :
    IndObjectPresentation B 
goal: (P.extend η).ℐ = P.ℐ

full_name: CategoryTheory.Limits.IndObjectPresentation.extend
code: /-- If `A` and `B` are isomorphic, then an ind-object presentation of `A` can be extended to an
    ind-object presentation of `B`. -/
@[simps!]
noncomputable def extend {A B : Cᵒᵖ ⥤ Type v} (P : IndObjectPresentation A) (η : A ⟶ B) [IsIso η] :
    IndObjectPresentation B 
goal: CategoryTheory.Limits.IndObjectPresentation B

full_name: CategoryTheory.Limits.IndObjectPresentation.extend_I
code: /-- If `A` and `B` are isomorphic, then an ind-object presentation of `A` can be extended to an
    ind-object presentation of `B`. -/
@[simps!]
noncomputable def extend {A B : Cᵒᵖ ⥤ Type v} (P : IndObjectPresentation A) (η : A ⟶ B) [IsIso η] :
    IndObjectPresentation B 
goal: (P.extend η).I = P.I

full_name: CategoryTheory.Limits.IndObjectPresentation.extend_isColimit_desc_app
code: /-- If `A` and `B` are isomorphic, then an ind-object presentation of `A` can be extended to an
    ind-object presentation of `B`. -/
@[simps!]
noncomputable def extend {A B : Cᵒᵖ ⥤ Type v} (P : IndObjectPresentation A) (η : A ⟶ B) [IsIso η] :
    IndObjectPresentation B 
goal: ∀ (a : (P.cocone.extend η).pt.obj X),
  ((P.extend η).isColimit.desc s).app X a = (P.coconeIsColimit.desc s).app X (CategoryTheory.inv (η.app X) a)

full_name: CategoryTheory.Limits.IndObjectPresentation.toCostructuredArrow_obj_hom
code: /-- The canonical comparison functor between the indexing category of the presentation and the
    comma category `CostructuredArrow yoneda A`. This functor is always final. -/
@[simps! obj_left obj_right_as obj_hom map_left]
def toCostructuredArrow : P.I ⥤ CostructuredArrow yoneda A 
goal: (P.toCostructuredArrow.obj X).hom = P.cocone.ι.app X

full_name: CategoryTheory.Limits.IndObjectPresentation.toCostructuredArrow_obj_right_as
code: /-- The canonical comparison functor between the indexing category of the presentation and the
    comma category `CostructuredArrow yoneda A`. This functor is always final. -/
@[simps! obj_left obj_right_as obj_hom map_left]
def toCostructuredArrow : P.I ⥤ CostructuredArrow yoneda A 
goal: (P.toCostructuredArrow.obj X).right.as = PUnit.unit

full_name: CategoryTheory.Limits.IndObjectPresentation.toCostructuredArrow
code: /-- The canonical comparison functor between the indexing category of the presentation and the
    comma category `CostructuredArrow yoneda A`. This functor is always final. -/
@[simps! obj_left obj_right_as obj_hom map_left]
def toCostructuredArrow : P.I ⥤ CostructuredArrow yoneda A 
goal: CategoryTheory.Functor P.I (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)

full_name: CategoryTheory.Limits.IndObjectPresentation.toCostructuredArrow_map_left
code: /-- The canonical comparison functor between the indexing category of the presentation and the
    comma category `CostructuredArrow yoneda A`. This functor is always final. -/
@[simps! obj_left obj_right_as obj_hom map_left]
def toCostructuredArrow : P.I ⥤ CostructuredArrow yoneda A 
goal: ∀ {X Y : P.I} (f : X ⟶ Y), (P.toCostructuredArrow.map f).left = P.F.map f

full_name: CategoryTheory.Limits.IndObjectPresentation.toCostructuredArrow_obj_left
code: /-- The canonical comparison functor between the indexing category of the presentation and the
    comma category `CostructuredArrow yoneda A`. This functor is always final. -/
@[simps! obj_left obj_right_as obj_hom map_left]
def toCostructuredArrow : P.I ⥤ CostructuredArrow yoneda A 
goal: (P.toCostructuredArrow.obj X).left = P.F.obj X

full_name: CategoryTheory.Limits.IndObjectPresentation.instFinalICostructuredArrowFunctorOppositeTypeYonedaToCostructuredArrow
code: instance : P.toCostructuredArrow.Final 
goal: P.toCostructuredArrow.Final

full_name: CategoryTheory.Limits.IndObjectPresentation.yoneda_F
code: /-- Representable presheaves are (trivially) ind-objects. -/
@[simps]
def yoneda (X : C) : IndObjectPresentation (yoneda.obj X) 
goal: (CategoryTheory.Limits.IndObjectPresentation.yoneda X).F = CategoryTheory.Functor.fromPUnit X

full_name: CategoryTheory.Limits.IndObjectPresentation.yoneda
code: /-- Representable presheaves are (trivially) ind-objects. -/
@[simps]
def yoneda (X : C) : IndObjectPresentation (yoneda.obj X) 
goal: CategoryTheory.Limits.IndObjectPresentation (CategoryTheory.yoneda.obj X)

full_name: CategoryTheory.Limits.IndObjectPresentation.yoneda_I
code: /-- Representable presheaves are (trivially) ind-objects. -/
@[simps]
def yoneda (X : C) : IndObjectPresentation (yoneda.obj X) 
goal: (CategoryTheory.Limits.IndObjectPresentation.yoneda X).I = CategoryTheory.Discrete PUnit.{v + 1}

full_name: CategoryTheory.Limits.IndObjectPresentation.yoneda_ℐ
code: /-- Representable presheaves are (trivially) ind-objects. -/
@[simps]
def yoneda (X : C) : IndObjectPresentation (yoneda.obj X) 
goal: (CategoryTheory.Limits.IndObjectPresentation.yoneda X).ℐ = CategoryTheory.discreteCategory PUnit.{v + 1}

full_name: CategoryTheory.Limits.IndObjectPresentation.yoneda_ι_app
code: /-- Representable presheaves are (trivially) ind-objects. -/
@[simps]
def yoneda (X : C) : IndObjectPresentation (yoneda.obj X) 
goal: (CategoryTheory.Limits.IndObjectPresentation.yoneda X).ι.app s =
  CategoryTheory.CategoryStruct.id (((CategoryTheory.Functor.fromPUnit X).comp CategoryTheory.yoneda).obj s)

full_name: CategoryTheory.Limits.IndObjectPresentation.yoneda_isColimit_desc
code: /-- Representable presheaves are (trivially) ind-objects. -/
@[simps]
def yoneda (X : C) : IndObjectPresentation (yoneda.obj X) 
goal: (CategoryTheory.Limits.IndObjectPresentation.yoneda X).isColimit.desc s = s.ι.app { as := PUnit.unit }

full_name: CategoryTheory.Limits.IsIndObject
code: /-- A presheaf is called an ind-object if it can be written as a filtered colimit of representable
    presheaves. -/
structure IsIndObject (A : Cᵒᵖ ⥤ Type v) : Prop where
  mk' :: nonempty_presentation : Nonempty (IndObjectPresentation A)
goal: Prop

full_name: CategoryTheory.Limits.IsIndObject.mk'
code: /-- A presheaf is called an ind-object if it can be written as a filtered colimit of representable
    presheaves. -/
structure IsIndObject (A : Cᵒᵖ ⥤ Type v) : Prop where
  mk' :: nonempty_presentation : Nonempty (IndObjectPresentation A)
goal: CategoryTheory.Limits.IsIndObject A

full_name: CategoryTheory.Limits.IsIndObject.nonempty_presentation
code: /-- A presheaf is called an ind-object if it can be written as a filtered colimit of representable
    presheaves. -/
structure IsIndObject (A : Cᵒᵖ ⥤ Type v) : Prop where
  mk' :: nonempty_presentation : Nonempty (IndObjectPresentation A)
goal: Nonempty (CategoryTheory.Limits.IndObjectPresentation A)

full_name: CategoryTheory.Limits.IsIndObject.mk
code: theorem IsIndObject.mk {A : Cᵒᵖ ⥤ Type v} (P : IndObjectPresentation A) : IsIndObject A 
goal: CategoryTheory.Limits.IsIndObject A

full_name: CategoryTheory.Limits.isIndObject_yoneda
code: /-- Representable presheaves are (trivially) ind-objects. -/
theorem isIndObject_yoneda (X : C) : IsIndObject (yoneda.obj X) 
goal: CategoryTheory.Limits.IsIndObject (CategoryTheory.yoneda.obj X)

full_name: CategoryTheory.Limits.IsIndObject.map
code: theorem map {A B : Cᵒᵖ ⥤ Type v} (η : A ⟶ B) [IsIso η] : IsIndObject A → IsIndObject B
  
goal: CategoryTheory.Limits.IsIndObject A → CategoryTheory.Limits.IsIndObject B

full_name: CategoryTheory.Limits.IsIndObject.iff_of_iso
code: theorem iff_of_iso {A B : Cᵒᵖ ⥤ Type v} (η : A ⟶ B) [IsIso η] : IsIndObject A ↔ IsIndObject B 
goal: CategoryTheory.Limits.IsIndObject A ↔ CategoryTheory.Limits.IsIndObject B

full_name: CategoryTheory.Limits.IsIndObject.presentation
code: /-- Pick a presentation for an ind-object using choice. -/
noncomputable def presentation : IsIndObject A → IndObjectPresentation A
  
goal: CategoryTheory.Limits.IsIndObject A → CategoryTheory.Limits.IndObjectPresentation A

full_name: CategoryTheory.Limits.IsIndObject.isFiltered
code: theorem isFiltered (h : IsIndObject A) : IsFiltered (CostructuredArrow yoneda A) 
goal: CategoryTheory.IsFiltered (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)

full_name: CategoryTheory.Limits.IsIndObject.finallySmall
code: theorem finallySmall (h : IsIndObject A) : FinallySmall.{v} (CostructuredArrow yoneda A) 
goal: CategoryTheory.FinallySmall (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)

full_name: CategoryTheory.Limits.isIndObject_of_isFiltered_of_finallySmall
code: theorem isIndObject_of_isFiltered_of_finallySmall (A : Cᵒᵖ ⥤ Type v)
    [IsFiltered (CostructuredArrow yoneda A)] [FinallySmall.{v} (CostructuredArrow yoneda A)] :
    IsIndObject A 
goal: CategoryTheory.Limits.IsIndObject A

full_name: CategoryTheory.Limits.isIndObject_iff
code: /-- The recognition theorem for ind-objects: `A : Cᵒᵖ ⥤ Type v` is an ind-object if and only if
    `CostructuredArrow yoneda A` is filtered and finally `v`-small.

    Theorem 6.1.5 of [Kashiwara2006] -/
theorem isIndObject_iff (A : Cᵒᵖ ⥤ Type v) : IsIndObject A ↔
    (IsFiltered (CostructuredArrow yoneda A) ∧ FinallySmall.{v} (CostructuredArrow yoneda A)) 
goal: CategoryTheory.Limits.IsIndObject A ↔
  CategoryTheory.IsFiltered (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A) ∧
    CategoryTheory.FinallySmall (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)