File: Mathlib/CategoryTheory/Limits/Presheaf.lean

full_name: CategoryTheory.Presheaf.restrictedYoneda_obj_obj
code: /--
The functor taking `(E : ℰ) (c : Cᵒᵖ)` to the homset `(A.obj C ⟶ E)`. It is shown in `L_adjunction`
that this functor has a left adjoint (provided `E` has colimits) given by taking colimits over
categories of elements.
In the case where `ℰ = Cᵒᵖ ⥤ Type u` and `A = yoneda`, this functor is isomorphic to the identity.

Defined as in [MM92], Chapter I, Section 5, Theorem 2.
-/
@[simps!]
def restrictedYoneda : ℰ ⥤ Cᵒᵖ ⥤ Type v₁ 
goal: ∀ (X_1 : Cᵒᵖ), ((CategoryTheory.Presheaf.restrictedYoneda A).obj X).obj X_1 = (A.obj (Opposite.unop X_1) ⟶ X)

full_name: CategoryTheory.Presheaf.restrictedYoneda_map_app
code: /--
The functor taking `(E : ℰ) (c : Cᵒᵖ)` to the homset `(A.obj C ⟶ E)`. It is shown in `L_adjunction`
that this functor has a left adjoint (provided `E` has colimits) given by taking colimits over
categories of elements.
In the case where `ℰ = Cᵒᵖ ⥤ Type u` and `A = yoneda`, this functor is isomorphic to the identity.

Defined as in [MM92], Chapter I, Section 5, Theorem 2.
-/
@[simps!]
def restrictedYoneda : ℰ ⥤ Cᵒᵖ ⥤ Type v₁ 
goal: ∀ {X Y : ℰ} (f : X ⟶ Y) (X_1 : Cᵒᵖ) (a : (CategoryTheory.yoneda.obj X).obj (A.op.obj X_1)),
  ((CategoryTheory.Presheaf.restrictedYoneda A).map f).app X_1 a = CategoryTheory.CategoryStruct.comp a f

full_name: CategoryTheory.Presheaf.restrictedYoneda
code: /--
The functor taking `(E : ℰ) (c : Cᵒᵖ)` to the homset `(A.obj C ⟶ E)`. It is shown in `L_adjunction`
that this functor has a left adjoint (provided `E` has colimits) given by taking colimits over
categories of elements.
In the case where `ℰ = Cᵒᵖ ⥤ Type u` and `A = yoneda`, this functor is isomorphic to the identity.

Defined as in [MM92], Chapter I, Section 5, Theorem 2.
-/
@[simps!]
def restrictedYoneda : ℰ ⥤ Cᵒᵖ ⥤ Type v₁ 
goal: CategoryTheory.Functor ℰ (CategoryTheory.Functor Cᵒᵖ (Type v₁))

full_name: CategoryTheory.Presheaf.restrictedYoneda_obj_map
code: /--
The functor taking `(E : ℰ) (c : Cᵒᵖ)` to the homset `(A.obj C ⟶ E)`. It is shown in `L_adjunction`
that this functor has a left adjoint (provided `E` has colimits) given by taking colimits over
categories of elements.
In the case where `ℰ = Cᵒᵖ ⥤ Type u` and `A = yoneda`, this functor is isomorphic to the identity.

Defined as in [MM92], Chapter I, Section 5, Theorem 2.
-/
@[simps!]
def restrictedYoneda : ℰ ⥤ Cᵒᵖ ⥤ Type v₁ 
goal: ∀ {X_1 Y : Cᵒᵖ} (f : X_1 ⟶ Y) (a : (CategoryTheory.yoneda.obj X).obj (A.op.obj X_1)),
  ((CategoryTheory.Presheaf.restrictedYoneda A).obj X).map f a = CategoryTheory.CategoryStruct.comp (A.map f.unop) a

full_name: CategoryTheory.Presheaf.restrictedYonedaHomEquiv'
code: /-- Auxiliary definition for `restrictedYonedaHomEquiv`. -/
def restrictedYonedaHomEquiv' (P : Cᵒᵖ ⥤ Type v₁) (E : ℰ) :
    (CostructuredArrow.proj yoneda P ⋙ A ⟶
      (Functor.const (CostructuredArrow yoneda P)).obj E) ≃
      (P ⟶ (restrictedYoneda A).obj E) 
goal: ((CategoryTheory.CostructuredArrow.proj CategoryTheory.yoneda P).comp A ⟶
    (CategoryTheory.Functor.const (CategoryTheory.CostructuredArrow CategoryTheory.yoneda P)).obj E) ≃
  (P ⟶ (CategoryTheory.Presheaf.restrictedYoneda A).obj E)

full_name: CategoryTheory.Presheaf.restrictedYonedaHomEquiv
code: /-- Auxiliary definition for `yonedaAdjunction`. -/
noncomputable def restrictedYonedaHomEquiv (P : Cᵒᵖ ⥤ Type v₁) (E : ℰ) :
    (L.obj P ⟶ E) ≃ (P ⟶ (restrictedYoneda A).obj E) 
goal: (L.obj P ⟶ E) ≃ (P ⟶ (CategoryTheory.Presheaf.restrictedYoneda A).obj E)

full_name: CategoryTheory.Presheaf.yonedaAdjunction
code: /-- If `L : (Cᵒᵖ ⥤ Type v₁) ⥤ ℰ` is a pointwise left Kan extension
of a functor `A : C ⥤ ℰ` along the Yoneda embedding,
then `L` is a left adjoint of `restrictedYoneda A : ℰ ⥤ Cᵒᵖ ⥤ Type v₁` -/
noncomputable def yonedaAdjunction : L ⊣ restrictedYoneda A 
goal: L ⊣ CategoryTheory.Presheaf.restrictedYoneda A

full_name: CategoryTheory.Presheaf.preservesColimitsOfSizeOfIsLeftKanExtension
code: /-- Any left Kan extension along the Yoneda embedding preserves colimits. -/
noncomputable def preservesColimitsOfSizeOfIsLeftKanExtension :
    PreservesColimitsOfSize.{v₃, u₃} L 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{v₃, u₃, max u₁ v₁, v₁, max u₁ (v₁ + 1), u₂} L

full_name: CategoryTheory.Presheaf.isIso_of_isLeftKanExtension
code: lemma isIso_of_isLeftKanExtension : IsIso α 
goal: CategoryTheory.IsIso α

full_name: CategoryTheory.Presheaf.preservesColimitsOfSizeLeftKanExtension
code: /-- See Property 2 of https://ncatlab.org/nlab/show/Yoneda+extension#properties. -/
noncomputable instance preservesColimitsOfSizeLeftKanExtension :
    PreservesColimitsOfSize.{v₃, u₃} (yoneda.leftKanExtension A) 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{v₃, u₃, max v₁ u₁, v₁, max (v₁ + 1) u₁, u₂}
  (CategoryTheory.yoneda.leftKanExtension A)

full_name: CategoryTheory.Presheaf.instIsIsoFunctorLeftKanExtensionUnitOppositeTypeYoneda
code: instance : IsIso (yoneda.leftKanExtensionUnit A) 
goal: CategoryTheory.IsIso (CategoryTheory.yoneda.leftKanExtensionUnit A)

full_name: CategoryTheory.Presheaf.isExtensionAlongYoneda
code: /-- A pointwise left Kan extension along the Yoneda embedding is an extension. -/
noncomputable def isExtensionAlongYoneda :
    yoneda ⋙ yoneda.leftKanExtension A ≅ A 
goal: CategoryTheory.yoneda.comp (CategoryTheory.yoneda.leftKanExtension A) ≅ A

full_name: CategoryTheory.Presheaf.functorToRepresentables
code: /-- A functor to the presheaf category in which everything in the image is representable (witnessed
by the fact that it factors through the yoneda embedding).
`coconeOfRepresentable` gives a cocone for this functor which is a colimit and has point `P`.
-/
@[reducible]
def functorToRepresentables (P : Cᵒᵖ ⥤ Type v₁) : P.Elementsᵒᵖ ⥤ Cᵒᵖ ⥤ Type v₁ 
goal: CategoryTheory.Functor P.Elementsᵒᵖ (CategoryTheory.Functor Cᵒᵖ (Type v₁))

full_name: CategoryTheory.Presheaf.coconeOfRepresentable_pt
code: /-- This is a cocone with point `P` for the functor `functorToRepresentables P`. It is shown in
`colimitOfRepresentable P` that this cocone is a colimit: that is, we have exhibited an arbitrary
presheaf `P` as a colimit of representables.

The construction of [MM92], Chapter I, Section 5, Corollary 3.
-/
@[simps]
noncomputable def coconeOfRepresentable (P : Cᵒᵖ ⥤ Type v₁) :
    Cocone (functorToRepresentables P) 
goal: (CategoryTheory.Presheaf.coconeOfRepresentable P).pt = P

full_name: CategoryTheory.Presheaf.coconeOfRepresentable_ι_app
code: /-- This is a cocone with point `P` for the functor `functorToRepresentables P`. It is shown in
`colimitOfRepresentable P` that this cocone is a colimit: that is, we have exhibited an arbitrary
presheaf `P` as a colimit of representables.

The construction of [MM92], Chapter I, Section 5, Corollary 3.
-/
@[simps]
noncomputable def coconeOfRepresentable (P : Cᵒᵖ ⥤ Type v₁) :
    Cocone (functorToRepresentables P) 
goal: (CategoryTheory.Presheaf.coconeOfRepresentable P).ι.app x = CategoryTheory.yonedaEquiv.symm (Opposite.unop x).snd

full_name: CategoryTheory.Presheaf.coconeOfRepresentable
code: /-- This is a cocone with point `P` for the functor `functorToRepresentables P`. It is shown in
`colimitOfRepresentable P` that this cocone is a colimit: that is, we have exhibited an arbitrary
presheaf `P` as a colimit of representables.

The construction of [MM92], Chapter I, Section 5, Corollary 3.
-/
@[simps]
noncomputable def coconeOfRepresentable (P : Cᵒᵖ ⥤ Type v₁) :
    Cocone (functorToRepresentables P) 
goal: CategoryTheory.Limits.Cocone (CategoryTheory.Presheaf.functorToRepresentables P)

full_name: CategoryTheory.Presheaf.coconeOfRepresentable_naturality
code: /-- The legs of the cocone `coconeOfRepresentable` are natural in the choice of presheaf. -/
theorem coconeOfRepresentable_naturality {P₁ P₂ : Cᵒᵖ ⥤ Type v₁} (α : P₁ ⟶ P₂) (j : P₁.Elementsᵒᵖ) :
    (coconeOfRepresentable P₁).ι.app j ≫ α =
      (coconeOfRepresentable P₂).ι.app ((CategoryOfElements.map α).op.obj j) 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.Presheaf.coconeOfRepresentable P₁).ι.app j) α =
  (CategoryTheory.Presheaf.coconeOfRepresentable P₂).ι.app ((CategoryTheory.CategoryOfElements.map α).op.obj j)

full_name: CategoryTheory.Presheaf.colimitOfRepresentable
code: /-- The cocone with point `P` given by `coconeOfRepresentable` is a colimit:
that is, we have exhibited an arbitrary presheaf `P` as a colimit of representables.

The result of [MM92], Chapter I, Section 5, Corollary 3.
-/
noncomputable def colimitOfRepresentable (P : Cᵒᵖ ⥤ Type v₁) :
    IsColimit (coconeOfRepresentable P) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Presheaf.coconeOfRepresentable P)

full_name: CategoryTheory.Presheaf.instIsIsoFunctorOfIsLeftKanExtensionOppositeType
code: instance [L.IsLeftKanExtension α] : IsIso α 
goal: CategoryTheory.IsIso α

full_name: CategoryTheory.Presheaf.isLeftKanExtension_along_yoneda_iff
code: lemma isLeftKanExtension_along_yoneda_iff :
    L.IsLeftKanExtension α ↔
      (IsIso α ∧ Nonempty (PreservesColimitsOfSize.{v₁, max u₁ v₁} L)) 
goal: L.IsLeftKanExtension α ↔
  CategoryTheory.IsIso α ∧
    Nonempty (CategoryTheory.Limits.PreservesColimitsOfSize.{v₁, max u₁ v₁, max u₁ v₁, v₁, max u₁ (v₁ + 1), u₂} L)

full_name: CategoryTheory.Presheaf.isLeftKanExtension_of_preservesColimits
code: lemma isLeftKanExtension_of_preservesColimits
    (L : (Cᵒᵖ ⥤ Type v₁) ⥤ ℰ) (e : A ≅ yoneda ⋙ L)
    [PreservesColimitsOfSize.{v₁, max u₁ v₁} L] :
    L.IsLeftKanExtension e.hom 
goal: L.IsLeftKanExtension e.hom

full_name: CategoryTheory.Presheaf.uniqueExtensionAlongYoneda
code: /-- Show that `yoneda.leftKanExtension A` is the unique colimit-preserving
functor which extends `A` to the presheaf category.

The second part of [MM92], Chapter I, Section 5, Corollary 4.
See Property 3 of https://ncatlab.org/nlab/show/Yoneda+extension#properties.
-/
noncomputable def uniqueExtensionAlongYoneda (L : (Cᵒᵖ ⥤ Type v₁) ⥤ ℰ) (e : A ≅ yoneda ⋙ L)
    [PreservesColimitsOfSize.{v₁, max u₁ v₁} L] : L ≅ yoneda.leftKanExtension A 
goal: L ≅ CategoryTheory.yoneda.leftKanExtension A

full_name: CategoryTheory.Presheaf.instIsLeftKanExtensionFunctorOppositeTypeIdCompYonedaOfPreservesColimitsOfSizeOfHasPointwiseLeftKanExtension
code: instance (L : (Cᵒᵖ ⥤ Type v₁) ⥤ ℰ) [PreservesColimitsOfSize.{v₁, max u₁ v₁} L]
    [yoneda.HasPointwiseLeftKanExtension (yoneda ⋙ L)] :
    L.IsLeftKanExtension (𝟙 _ : yoneda ⋙ L ⟶ _) 
goal: L.IsLeftKanExtension (CategoryTheory.CategoryStruct.id (CategoryTheory.yoneda.comp L))

full_name: CategoryTheory.Presheaf.isLeftAdjoint_of_preservesColimits
code: /-- If `L` preserves colimits and `ℰ` has them, then it is a left adjoint. Note this is a (partial)
converse to `leftAdjointPreservesColimits`.
-/
lemma isLeftAdjoint_of_preservesColimits (L : (C ⥤ Type v₁) ⥤ ℰ)
    [PreservesColimitsOfSize.{v₁, max u₁ v₁} L]
    [yoneda.HasPointwiseLeftKanExtension
      (yoneda ⋙ (opOpEquivalence C).congrLeft.functor.comp L)] :
    L.IsLeftAdjoint 
goal: L.IsLeftAdjoint

full_name: CategoryTheory.Presheaf.instUniqueHomLeftExtensionOppositeOpObjFunctorTypeYonedaMkYonedaMap
code: instance (X : C) (Y : F.op.LeftExtension (yoneda.obj X)) :
    Unique (Functor.LeftExtension.mk _ (yonedaMap F X) ⟶ Y) 
goal: Unique
  (CategoryTheory.Functor.LeftExtension.mk (CategoryTheory.yoneda.obj (F.obj X)) (CategoryTheory.yonedaMap F X) ⟶ Y)

full_name: CategoryTheory.Presheaf.instIsLeftKanExtensionOppositeObjFunctorTypeYonedaYonedaMap
code: /-- Given `F : C ⥤ D` and `X : C`, `yoneda.obj (F.obj X) : Dᵒᵖ ⥤ Type _` is the
left Kan extension of `yoneda.obj X : Cᵒᵖ ⥤ Type _` along `F.op`. -/
instance (X : C) : (yoneda.obj (F.obj X)).IsLeftKanExtension (yonedaMap F X) 
goal: (CategoryTheory.yoneda.obj (F.obj X)).IsLeftKanExtension (CategoryTheory.yonedaMap F X)

full_name: CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan
code: /-- `F ⋙ yoneda` is naturally isomorphic to `yoneda ⋙ F.op.lan`. -/
noncomputable def compYonedaIsoYonedaCompLan :
    F ⋙ yoneda ≅ yoneda ⋙ F.op.lan 
goal: F.comp CategoryTheory.yoneda ≅ CategoryTheory.yoneda.comp F.op.lan

full_name: CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan_inv_app_app_apply_eq_id
code: @[simp]
lemma compYonedaIsoYonedaCompLan_inv_app_app_apply_eq_id (X : C) :
    ((compYonedaIsoYonedaCompLan F).inv.app X).app (Opposite.op (F.obj X))
      ((F.op.lanUnit.app (yoneda.obj X)).app _ (𝟙 X)) = 𝟙 _ 
goal: ((CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan F).inv.app X).app (Opposite.op (F.obj X))
    ((F.op.lanUnit.app (CategoryTheory.yoneda.obj X)).app (Opposite.op X) (CategoryTheory.CategoryStruct.id X)) =
  CategoryTheory.CategoryStruct.id (Opposite.unop (Opposite.op (F.obj X)))

full_name: CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.coconeApp
code: /-- Auxiliary definition for `presheafHom`. -/
def coconeApp {P : Cᵒᵖ ⥤ Type v₁} (x : P.Elements) :
    yoneda.obj x.1.unop ⟶ F.op ⋙ G.obj P 
goal: CategoryTheory.yoneda.obj (Opposite.unop x.fst) ⟶ F.op.comp (G.obj P)

full_name: CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.coconeApp_naturality
code: @[reassoc (attr := simp)]
lemma coconeApp_naturality {P : Cᵒᵖ ⥤ Type v₁} {x y : P.Elements} (f : x ⟶ y) :
    yoneda.map f.1.unop ≫ coconeApp φ x = coconeApp φ y 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map (↑f).unop)
    (CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.coconeApp φ x) =
  CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.coconeApp φ y

full_name: CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.presheafHom
code: /-- Given functors `F : C ⥤ D` and `G : (Cᵒᵖ ⥤ Type v₁) ⥤ (Dᵒᵖ ⥤ Type v₁)`, and
a natural transformation `φ : F ⋙ yoneda ⟶ yoneda ⋙ G`, this is the
(natural) morphism `P ⟶ F.op ⋙ G.obj P` for all `P : Cᵒᵖ ⥤ Type v₁` that is
determined by `φ`. -/
noncomputable def presheafHom (P : Cᵒᵖ ⥤ Type v₁) : P ⟶ F.op ⋙ G.obj P 
goal: P ⟶ F.op.comp (G.obj P)

full_name: CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.yonedaEquiv_ι_presheafHom
code: lemma yonedaEquiv_ι_presheafHom (P : Cᵒᵖ ⥤ Type v₁) {X : C} (f : yoneda.obj X ⟶ P) :
    yonedaEquiv (f ≫ presheafHom φ P) =
      (G.map f).app (Opposite.op (F.obj X)) ((φ.app X).app _ (𝟙 _)) 
goal: CategoryTheory.yonedaEquiv
    (CategoryTheory.CategoryStruct.comp f (CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.presheafHom φ P)) =
  (G.map f).app (Opposite.op (F.obj X))
    ((φ.app X).app (Opposite.op (F.obj X)) (CategoryTheory.CategoryStruct.id (Opposite.unop (Opposite.op (F.obj X)))))

full_name: CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.yonedaEquiv_presheafHom_yoneda_obj
code: lemma yonedaEquiv_presheafHom_yoneda_obj (X : C) :
    yonedaEquiv (presheafHom φ (yoneda.obj X)) =
      ((φ.app X).app (F.op.obj (Opposite.op X)) (𝟙 _)) 
goal: CategoryTheory.yonedaEquiv
    (CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.presheafHom φ (CategoryTheory.yoneda.obj X)) =
  (φ.app X).app (F.op.obj (Opposite.op X)) (CategoryTheory.CategoryStruct.id (Opposite.unop (F.op.obj (Opposite.op X))))

full_name: CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.presheafHom_naturality
code: @[reassoc (attr := simp)]
lemma presheafHom_naturality {P Q : Cᵒᵖ ⥤ Type v₁} (f : P ⟶ Q) :
    presheafHom φ P ≫ whiskerLeft F.op (G.map f) = f ≫ presheafHom φ Q 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.presheafHom φ P)
    (CategoryTheory.whiskerLeft F.op (G.map f)) =
  CategoryTheory.CategoryStruct.comp f (CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.presheafHom φ Q)

full_name: CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.natTrans
code: /-- Given functors `F : C ⥤ D` and `G : (Cᵒᵖ ⥤ Type v₁) ⥤ (Dᵒᵖ ⥤ Type v₁)`,
and a natural transformation `φ : F ⋙ yoneda ⟶ yoneda ⋙ G`, this is
the canonical natural transformation `F.op.lan ⟶ G`, which is part of the
that `F.op.lan : (Cᵒᵖ ⥤ Type v₁) ⥤ Dᵒᵖ ⥤ Type v₁` is the left Kan extension
of `F ⋙ yoneda : C ⥤ Dᵒᵖ ⥤ Type v₁` along `yoneda : C ⥤ Cᵒᵖ ⥤ Type v₁`. -/
noncomputable def natTrans : F.op.lan ⟶ G 
goal: F.op.lan ⟶ G

full_name: CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.natTrans_app_yoneda_obj
code: lemma natTrans_app_yoneda_obj (X : C) : (natTrans φ).app (yoneda.obj X) =
    (compYonedaIsoYonedaCompLan F).inv.app X ≫ φ.app X 
goal: (CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.natTrans φ).app (CategoryTheory.yoneda.obj X) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan F).inv.app X) (φ.app X)

full_name: CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.extensionHom
code: /-- Given a functor `F : C ⥤ D`, this definition is part of the verification that
`Functor.LeftExtension.mk F.op.lan (compYonedaIsoYonedaCompLan F).hom`
is universal, i.e. that  `F.op.lan : (Cᵒᵖ ⥤ Type v₁) ⥤ Dᵒᵖ ⥤ Type v₁` is the
left Kan extension of `F ⋙ yoneda : C ⥤ Dᵒᵖ ⥤ Type v₁`
along `yoneda : C ⥤ Cᵒᵖ ⥤ Type v₁`. -/
noncomputable def extensionHom (Φ : yoneda.LeftExtension (F ⋙ yoneda)) :
    Functor.LeftExtension.mk F.op.lan (compYonedaIsoYonedaCompLan F).hom ⟶ Φ 
goal: CategoryTheory.Functor.LeftExtension.mk F.op.lan (CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan F).hom ⟶ Φ

full_name: CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.hom_ext
code: @[ext]
lemma hom_ext {Φ : yoneda.LeftExtension (F ⋙ yoneda)}
    (f g : Functor.LeftExtension.mk F.op.lan (compYonedaIsoYonedaCompLan F).hom ⟶ Φ) :
    f = g 
goal: f = g

full_name: CategoryTheory.Presheaf.instUniqueHomLeftExtensionFunctorOppositeTypeYonedaCompMkLanOpHomCompYonedaIsoYonedaCompLan
code: noncomputable instance (Φ : StructuredArrow (F ⋙ yoneda)
    ((whiskeringLeft C (Cᵒᵖ ⥤ Type v₁) (Dᵒᵖ ⥤ Type v₁)).obj yoneda)) :
    Unique (Functor.LeftExtension.mk F.op.lan (compYonedaIsoYonedaCompLan F).hom ⟶ Φ) 
goal: Unique (CategoryTheory.Functor.LeftExtension.mk F.op.lan (CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan F).hom ⟶ Φ)

full_name: CategoryTheory.Presheaf.instIsLeftKanExtensionFunctorOppositeTypeLanOpHomCompYonedaIsoYonedaCompLan
code: /-- Given a functor `F : C ⥤ D`, `F.op.lan : (Cᵒᵖ ⥤ Type v₁) ⥤ Dᵒᵖ ⥤ Type v₁` is the
left Kan extension of `F ⋙ yoneda : C ⥤ Dᵒᵖ ⥤ Type v₁` along `yoneda : C ⥤ Cᵒᵖ ⥤ Type v₁`. -/
instance : F.op.lan.IsLeftKanExtension (compYonedaIsoYonedaCompLan F).hom 
goal: F.op.lan.IsLeftKanExtension (CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan F).hom

full_name: CategoryTheory.Presheaf.tautologicalCocone_pt
code: /-- For a presheaf `P`, consider the forgetful functor from the category of representable
    presheaves over `P` to the category of presheaves. There is a tautological cocone over this
    functor whose leg for a natural transformation `V ⟶ P` with `V` representable is just that
    natural transformation. -/
@[simps]
def tautologicalCocone : Cocone (CostructuredArrow.proj yoneda P ⋙ yoneda) 
goal: (CategoryTheory.Presheaf.tautologicalCocone P).pt = P

full_name: CategoryTheory.Presheaf.tautologicalCocone_ι_app
code: /-- For a presheaf `P`, consider the forgetful functor from the category of representable
    presheaves over `P` to the category of presheaves. There is a tautological cocone over this
    functor whose leg for a natural transformation `V ⟶ P` with `V` representable is just that
    natural transformation. -/
@[simps]
def tautologicalCocone : Cocone (CostructuredArrow.proj yoneda P ⋙ yoneda) 
goal: (CategoryTheory.Presheaf.tautologicalCocone P).ι.app X = X.hom

full_name: CategoryTheory.Presheaf.tautologicalCocone
code: /-- For a presheaf `P`, consider the forgetful functor from the category of representable
    presheaves over `P` to the category of presheaves. There is a tautological cocone over this
    functor whose leg for a natural transformation `V ⟶ P` with `V` representable is just that
    natural transformation. -/
@[simps]
def tautologicalCocone : Cocone (CostructuredArrow.proj yoneda P ⋙ yoneda) 
goal: CategoryTheory.Limits.Cocone
  ((CategoryTheory.CostructuredArrow.proj CategoryTheory.yoneda P).comp CategoryTheory.yoneda)

full_name: CategoryTheory.Presheaf.isColimitTautologicalCocone
code: /-- The tautological cocone with point `P` is a colimit cocone, exhibiting `P` as a colimit of
    representables.

    Proposition 2.6.3(i) in [Kashiwara2006] -/
def isColimitTautologicalCocone : IsColimit (tautologicalCocone P) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Presheaf.tautologicalCocone P)

full_name: CategoryTheory.Presheaf.final_toCostructuredArrow_comp_pre
code: /-- Given a functor `F : I ⥤ C`, a cocone `c` on `F ⋙ yoneda : I ⥤ Cᵒᵖ ⥤ Type v₁` induces a
    functor `I ⥤ CostructuredArrow yoneda c.pt` which maps `i : I` to the leg
    `yoneda.obj (F.obj i) ⟶ c.pt`. If `c` is a colimit cocone, then that functor is
    final.

    Proposition 2.6.3(ii) in [Kashiwara2006] -/
theorem final_toCostructuredArrow_comp_pre {c : Cocone (F ⋙ yoneda)} (hc : IsColimit c) :
    Functor.Final (c.toCostructuredArrow ⋙ CostructuredArrow.pre F yoneda c.pt) 
goal: (c.toCostructuredArrow.comp (CategoryTheory.CostructuredArrow.pre F CategoryTheory.yoneda c.pt)).Final