File: Mathlib/CategoryTheory/Functor/KanExtension/Pointwise.lean

full_name: CategoryTheory.Functor.HasPointwiseLeftKanExtensionAt
code: /-- The condition that a functor `F` has a pointwise left Kan extension along `L` at `Y`.
It means that the functor `CostructuredArrow.proj L Y ⋙ F : CostructuredArrow L Y ⥤ H`
has a colimit. -/
abbrev HasPointwiseLeftKanExtensionAt (Y : D) 
goal: Prop

full_name: CategoryTheory.Functor.HasPointwiseLeftKanExtension
code: /-- The condition that a functor `F` has a pointwise left Kan extension along `L`: it means
that it has a pointwise left Kan extension at any object. -/
abbrev HasPointwiseLeftKanExtension 
goal: Prop

full_name: CategoryTheory.Functor.HasPointwiseRightKanExtensionAt
code: /-- The condition that a functor `F` has a pointwise right Kan extension along `L` at `Y`.
It means that the functor `StructuredArrow.proj Y L ⋙ F : StructuredArrow Y L ⥤ H`
has a limit. -/
abbrev HasPointwiseRightKanExtensionAt (Y : D) 
goal: Prop

full_name: CategoryTheory.Functor.HasPointwiseRightKanExtension
code: /-- The condition that a functor `F` has a pointwise right Kan extension along `L`: it means
that it has a pointwise right Kan extension at any object. -/
abbrev HasPointwiseRightKanExtension 
goal: Prop

full_name: CategoryTheory.Functor.LeftExtension.coconeAt_pt
code: /-- The cocone for `CostructuredArrow.proj L Y ⋙ F` attached to `E : LeftExtension L F`.
The point of this cocone is `E.right.obj Y` -/
@[simps]
def coconeAt (Y : D) : Cocone (CostructuredArrow.proj L Y ⋙ F) 
goal: (E.coconeAt Y).pt = E.right.obj Y

full_name: CategoryTheory.Functor.LeftExtension.coconeAt
code: /-- The cocone for `CostructuredArrow.proj L Y ⋙ F` attached to `E : LeftExtension L F`.
The point of this cocone is `E.right.obj Y` -/
@[simps]
def coconeAt (Y : D) : Cocone (CostructuredArrow.proj L Y ⋙ F) 
goal: CategoryTheory.Limits.Cocone ((CategoryTheory.CostructuredArrow.proj L Y).comp F)

full_name: CategoryTheory.Functor.LeftExtension.coconeAt_ι_app
code: /-- The cocone for `CostructuredArrow.proj L Y ⋙ F` attached to `E : LeftExtension L F`.
The point of this cocone is `E.right.obj Y` -/
@[simps]
def coconeAt (Y : D) : Cocone (CostructuredArrow.proj L Y ⋙ F) 
goal: (E.coconeAt Y).ι.app g = CategoryTheory.CategoryStruct.comp (E.hom.app g.left) (E.right.map g.hom)

full_name: CategoryTheory.Functor.LeftExtension.coconeAtFunctor_map_hom
code: /-- The cocones for `CostructuredArrow.proj L Y ⋙ F`, as a functor from `LeftExtension L F`. -/
@[simps]
def coconeAtFunctor (Y : D) :
    LeftExtension L F ⥤ Cocone (CostructuredArrow.proj L Y ⋙ F) 
goal: ((CategoryTheory.Functor.LeftExtension.coconeAtFunctor L F Y).map φ).hom = φ.right.app Y

full_name: CategoryTheory.Functor.LeftExtension.coconeAtFunctor
code: /-- The cocones for `CostructuredArrow.proj L Y ⋙ F`, as a functor from `LeftExtension L F`. -/
@[simps]
def coconeAtFunctor (Y : D) :
    LeftExtension L F ⥤ Cocone (CostructuredArrow.proj L Y ⋙ F) 
goal: CategoryTheory.Functor (L.LeftExtension F)
  (CategoryTheory.Limits.Cocone ((CategoryTheory.CostructuredArrow.proj L Y).comp F))

full_name: CategoryTheory.Functor.LeftExtension.coconeAtFunctor_obj
code: /-- The cocones for `CostructuredArrow.proj L Y ⋙ F`, as a functor from `LeftExtension L F`. -/
@[simps]
def coconeAtFunctor (Y : D) :
    LeftExtension L F ⥤ Cocone (CostructuredArrow.proj L Y ⋙ F) 
goal: (CategoryTheory.Functor.LeftExtension.coconeAtFunctor L F Y).obj E = E.coconeAt Y

full_name: CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtensionAt
code: /-- A left extension `E : LeftExtension L F` is a pointwise left Kan extension at `Y` when
`E.coconeAt Y` is a colimit cocone. -/
def IsPointwiseLeftKanExtensionAt (Y : D) 
goal: Type (max (max (max u_1 u_5) u_3) u_6)

full_name: CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtensionAt.hasPointwiseLeftKanExtensionAt
code: lemma IsPointwiseLeftKanExtensionAt.hasPointwiseLeftKanExtensionAt
    {Y : D} (h : E.IsPointwiseLeftKanExtensionAt Y) :
    HasPointwiseLeftKanExtensionAt L F Y 
goal: L.HasPointwiseLeftKanExtensionAt F Y

full_name: CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtensionAt.isIso_hom_app
code: lemma IsPointwiseLeftKanExtensionAt.isIso_hom_app
    {X : C} (h : E.IsPointwiseLeftKanExtensionAt (L.obj X)) [L.Full] [L.Faithful] :
    IsIso (E.hom.app X) 
goal: CategoryTheory.IsIso (E.hom.app X)

full_name: CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtension
code: /-- A left extension `E : LeftExtension L F` is a pointwise left Kan extension when
it is a pointwise left Kan extension at any object. -/
abbrev IsPointwiseLeftKanExtension 
goal: Type (max (max (max (max u_2 u_6) u_5) u_3) u_1)

full_name: CategoryTheory.Functor.LeftExtension.isPointwiseLeftKanExtensionAtEquivOfIso
code: /-- If two left extensions `E` and `E'` are isomorphic, `E` is a pointwise
left Kan extension at `Y` iff `E'` is. -/
def isPointwiseLeftKanExtensionAtEquivOfIso (e : E ≅ E') (Y : D) :
    E.IsPointwiseLeftKanExtensionAt Y ≃ E'.IsPointwiseLeftKanExtensionAt Y 
goal: E.IsPointwiseLeftKanExtensionAt Y ≃ E'.IsPointwiseLeftKanExtensionAt Y

full_name: CategoryTheory.Functor.LeftExtension.isPointwiseLeftKanExtensionEquivOfIso
code: /-- If two left extensions `E` and `E'` are isomorphic, `E` is a pointwise
left Kan extension iff `E'` is. -/
def isPointwiseLeftKanExtensionEquivOfIso (e : E ≅ E') :
    E.IsPointwiseLeftKanExtension ≃ E'.IsPointwiseLeftKanExtension 
goal: E.IsPointwiseLeftKanExtension ≃ E'.IsPointwiseLeftKanExtension

full_name: CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtension.hasPointwiseLeftKanExtension
code: lemma IsPointwiseLeftKanExtension.hasPointwiseLeftKanExtension :
    HasPointwiseLeftKanExtension L F 
goal: L.HasPointwiseLeftKanExtension F

full_name: CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtension.homFrom
code: /-- The (unique) morphism from a pointwise left Kan extension. -/
def IsPointwiseLeftKanExtension.homFrom (G : LeftExtension L F) : E ⟶ G 
goal: E ⟶ G

full_name: CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtension.hom_ext
code: lemma IsPointwiseLeftKanExtension.hom_ext (h : E.IsPointwiseLeftKanExtension)
    {G : LeftExtension L F} {f₁ f₂ : E ⟶ G} : f₁ = f₂ 
goal: f₁ = f₂

full_name: CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtension.isUniversal
code: /-- A pointwise left Kan extension is universal, i.e. it is a left Kan extension. -/
def IsPointwiseLeftKanExtension.isUniversal : E.IsUniversal 
goal: CategoryTheory.StructuredArrow.IsUniversal E

full_name: CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtension.isLeftKanExtension
code: lemma IsPointwiseLeftKanExtension.isLeftKanExtension :
    E.right.IsLeftKanExtension E.hom 
goal: E.right.IsLeftKanExtension E.hom

full_name: CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtension.hasLeftKanExtension
code: lemma IsPointwiseLeftKanExtension.hasLeftKanExtension :
    HasLeftKanExtension L F 
goal: L.HasLeftKanExtension F

full_name: CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtension.isIso_hom
code: lemma IsPointwiseLeftKanExtension.isIso_hom [L.Full] [L.Faithful] :
    IsIso (E.hom) 
goal: CategoryTheory.IsIso E.hom

full_name: CategoryTheory.Functor.RightExtension.coneAt_pt
code: /-- The cone for `StructuredArrow.proj Y L ⋙ F` attached to `E : RightExtension L F`.
The point of this cone is `E.left.obj Y` -/
@[simps]
def coneAt (Y : D) : Cone (StructuredArrow.proj Y L ⋙ F) 
goal: (E.coneAt Y).pt = E.left.obj Y

full_name: CategoryTheory.Functor.RightExtension.coneAt_π_app
code: /-- The cone for `StructuredArrow.proj Y L ⋙ F` attached to `E : RightExtension L F`.
The point of this cone is `E.left.obj Y` -/
@[simps]
def coneAt (Y : D) : Cone (StructuredArrow.proj Y L ⋙ F) 
goal: (E.coneAt Y).π.app g = CategoryTheory.CategoryStruct.comp (E.left.map g.hom) (E.hom.app g.right)

full_name: CategoryTheory.Functor.RightExtension.coneAt
code: /-- The cone for `StructuredArrow.proj Y L ⋙ F` attached to `E : RightExtension L F`.
The point of this cone is `E.left.obj Y` -/
@[simps]
def coneAt (Y : D) : Cone (StructuredArrow.proj Y L ⋙ F) 
goal: CategoryTheory.Limits.Cone ((CategoryTheory.StructuredArrow.proj Y L).comp F)

full_name: CategoryTheory.Functor.RightExtension.coneAtFunctor
code: /-- The cones for `StructuredArrow.proj Y L ⋙ F`, as a functor from `RightExtension L F`. -/
@[simps]
def coneAtFunctor (Y : D) :
    RightExtension L F ⥤ Cone (StructuredArrow.proj Y L ⋙ F) 
goal: CategoryTheory.Functor (L.RightExtension F)
  (CategoryTheory.Limits.Cone ((CategoryTheory.StructuredArrow.proj Y L).comp F))

full_name: CategoryTheory.Functor.RightExtension.coneAtFunctor_obj
code: /-- The cones for `StructuredArrow.proj Y L ⋙ F`, as a functor from `RightExtension L F`. -/
@[simps]
def coneAtFunctor (Y : D) :
    RightExtension L F ⥤ Cone (StructuredArrow.proj Y L ⋙ F) 
goal: (CategoryTheory.Functor.RightExtension.coneAtFunctor L F Y).obj E = E.coneAt Y

full_name: CategoryTheory.Functor.RightExtension.coneAtFunctor_map_hom
code: /-- The cones for `StructuredArrow.proj Y L ⋙ F`, as a functor from `RightExtension L F`. -/
@[simps]
def coneAtFunctor (Y : D) :
    RightExtension L F ⥤ Cone (StructuredArrow.proj Y L ⋙ F) 
goal: ((CategoryTheory.Functor.RightExtension.coneAtFunctor L F Y).map φ).hom = φ.left.app Y

full_name: CategoryTheory.Functor.RightExtension.IsPointwiseRightKanExtensionAt
code: /-- A right extension `E : RightExtension L F` is a pointwise right Kan extension at `Y` when
`E.coneAt Y` is a limit cone. -/
def IsPointwiseRightKanExtensionAt (Y : D) 
goal: Type (max (max (max u_1 u_5) u_3) u_6)

full_name: CategoryTheory.Functor.RightExtension.IsPointwiseRightKanExtensionAt.hasPointwiseRightKanExtensionAt
code: lemma IsPointwiseRightKanExtensionAt.hasPointwiseRightKanExtensionAt
    {Y : D} (h : E.IsPointwiseRightKanExtensionAt Y) :
    HasPointwiseRightKanExtensionAt L F Y 
goal: L.HasPointwiseRightKanExtensionAt F Y

full_name: CategoryTheory.Functor.RightExtension.IsPointwiseRightKanExtensionAt.isIso_hom_app
code: lemma IsPointwiseRightKanExtensionAt.isIso_hom_app
    {X : C} (h : E.IsPointwiseRightKanExtensionAt (L.obj X)) [L.Full] [L.Faithful] :
    IsIso (E.hom.app X) 
goal: CategoryTheory.IsIso (E.hom.app X)

full_name: CategoryTheory.Functor.RightExtension.IsPointwiseRightKanExtension
code: /-- A right extension `E : RightExtension L F` is a pointwise right Kan extension when
it is a pointwise right Kan extension at any object. -/
abbrev IsPointwiseRightKanExtension 
goal: Type (max (max (max (max u_2 u_6) u_5) u_3) u_1)

full_name: CategoryTheory.Functor.RightExtension.isPointwiseRightKanExtensionAtEquivOfIso
code: /-- If two right extensions `E` and `E'` are isomorphic, `E` is a pointwise
right Kan extension at `Y` iff `E'` is. -/
def isPointwiseRightKanExtensionAtEquivOfIso (e : E ≅ E') (Y : D) :
    E.IsPointwiseRightKanExtensionAt Y ≃ E'.IsPointwiseRightKanExtensionAt Y 
goal: E.IsPointwiseRightKanExtensionAt Y ≃ E'.IsPointwiseRightKanExtensionAt Y

full_name: CategoryTheory.Functor.RightExtension.isPointwiseRightKanExtensionEquivOfIso
code: /-- If two right extensions `E` and `E'` are isomorphic, `E` is a pointwise
right Kan extension iff `E'` is. -/
def isPointwiseRightKanExtensionEquivOfIso (e : E ≅ E') :
    E.IsPointwiseRightKanExtension ≃ E'.IsPointwiseRightKanExtension 
goal: E.IsPointwiseRightKanExtension ≃ E'.IsPointwiseRightKanExtension

full_name: CategoryTheory.Functor.RightExtension.IsPointwiseRightKanExtension.hasPointwiseRightKanExtension
code: lemma IsPointwiseRightKanExtension.hasPointwiseRightKanExtension :
    HasPointwiseRightKanExtension L F 
goal: L.HasPointwiseRightKanExtension F

full_name: CategoryTheory.Functor.RightExtension.IsPointwiseRightKanExtension.homTo
code: /-- The (unique) morphism to a pointwise right Kan extension. -/
def IsPointwiseRightKanExtension.homTo (G : RightExtension L F) : G ⟶ E 
goal: G ⟶ E

full_name: CategoryTheory.Functor.RightExtension.IsPointwiseRightKanExtension.hom_ext
code: lemma IsPointwiseRightKanExtension.hom_ext (h : E.IsPointwiseRightKanExtension)
    {G : RightExtension L F} {f₁ f₂ : G ⟶ E} : f₁ = f₂ 
goal: f₁ = f₂

full_name: CategoryTheory.Functor.RightExtension.IsPointwiseRightKanExtension.isUniversal
code: /-- A pointwise right Kan extension is universal, i.e. it is a right Kan extension. -/
def IsPointwiseRightKanExtension.isUniversal : E.IsUniversal 
goal: CategoryTheory.CostructuredArrow.IsUniversal E

full_name: CategoryTheory.Functor.RightExtension.IsPointwiseRightKanExtension.isRightKanExtension
code: lemma IsPointwiseRightKanExtension.isRightKanExtension :
    E.left.IsRightKanExtension E.hom 
goal: E.left.IsRightKanExtension E.hom

full_name: CategoryTheory.Functor.RightExtension.IsPointwiseRightKanExtension.hasRightKanExtension
code: lemma IsPointwiseRightKanExtension.hasRightKanExtension :
    HasRightKanExtension L F 
goal: L.HasRightKanExtension F

full_name: CategoryTheory.Functor.RightExtension.IsPointwiseRightKanExtension.isIso_hom
code: lemma IsPointwiseRightKanExtension.isIso_hom [L.Full] [L.Faithful] :
    IsIso (E.hom) 
goal: CategoryTheory.IsIso E.hom

full_name: CategoryTheory.Functor.pointwiseLeftKanExtension
code: /-- The constructed pointwise left Kan extension when `HasPointwiseLeftKanExtension L F` holds. -/
@[simps]
noncomputable def pointwiseLeftKanExtension : D ⥤ H 
goal: CategoryTheory.Functor D H

full_name: CategoryTheory.Functor.pointwiseLeftKanExtension_map
code: /-- The constructed pointwise left Kan extension when `HasPointwiseLeftKanExtension L F` holds. -/
@[simps]
noncomputable def pointwiseLeftKanExtension : D ⥤ H 
goal: (L.pointwiseLeftKanExtension F).map f =
  CategoryTheory.Limits.colimit.desc ((CategoryTheory.CostructuredArrow.proj L Y₁).comp F)
    { pt := CategoryTheory.Limits.colimit ((CategoryTheory.CostructuredArrow.proj L Y₂).comp F),
      ι :=
        {
          app := fun g =>
            CategoryTheory.Limits.colimit.ι ((CategoryTheory.CostructuredArrow.proj L Y₂).comp F)
              ((CategoryTheory.CostructuredArrow.map f).obj g),
          naturality := ⋯ } }

full_name: CategoryTheory.Functor.pointwiseLeftKanExtension_obj
code: /-- The constructed pointwise left Kan extension when `HasPointwiseLeftKanExtension L F` holds. -/
@[simps]
noncomputable def pointwiseLeftKanExtension : D ⥤ H 
goal: (L.pointwiseLeftKanExtension F).obj Y =
  CategoryTheory.Limits.colimit ((CategoryTheory.CostructuredArrow.proj L Y).comp F)

full_name: CategoryTheory.Functor.pointwiseLeftKanExtensionUnit
code: /-- The unit of the constructed pointwise left Kan extension when
`HasPointwiseLeftKanExtension L F` holds. -/
@[simps]
noncomputable def pointwiseLeftKanExtensionUnit : F ⟶ L ⋙ pointwiseLeftKanExtension L F 
goal: F ⟶ L.comp (L.pointwiseLeftKanExtension F)

full_name: CategoryTheory.Functor.pointwiseLeftKanExtensionUnit_app
code: /-- The unit of the constructed pointwise left Kan extension when
`HasPointwiseLeftKanExtension L F` holds. -/
@[simps]
noncomputable def pointwiseLeftKanExtensionUnit : F ⟶ L ⋙ pointwiseLeftKanExtension L F 
goal: (L.pointwiseLeftKanExtensionUnit F).app X =
  CategoryTheory.Limits.colimit.ι ((CategoryTheory.CostructuredArrow.proj L (L.obj X)).comp F)
    (CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.id (L.obj X)))

full_name: CategoryTheory.Functor.pointwiseLeftKanExtensionIsPointwiseLeftKanExtension
code: /-- The functor `pointwiseLeftKanExtension L F` is a pointwise left Kan
extension of `F` along `L`. -/
noncomputable def pointwiseLeftKanExtensionIsPointwiseLeftKanExtension :
    (LeftExtension.mk _ (pointwiseLeftKanExtensionUnit L F)).IsPointwiseLeftKanExtension 
goal: (CategoryTheory.Functor.LeftExtension.mk (L.pointwiseLeftKanExtension F)
    (L.pointwiseLeftKanExtensionUnit F)).IsPointwiseLeftKanExtension

full_name: CategoryTheory.Functor.pointwiseLeftKanExtensionIsUniversal
code: /-- The functor `pointwiseLeftKanExtension L F` is a left Kan extension of `F` along `L`. -/
noncomputable def pointwiseLeftKanExtensionIsUniversal :
    (LeftExtension.mk _ (pointwiseLeftKanExtensionUnit L F)).IsUniversal 
goal: CategoryTheory.StructuredArrow.IsUniversal
  (CategoryTheory.Functor.LeftExtension.mk (L.pointwiseLeftKanExtension F) (L.pointwiseLeftKanExtensionUnit F))

full_name: CategoryTheory.Functor.instIsLeftKanExtensionPointwiseLeftKanExtensionPointwiseLeftKanExtensionUnit
code: instance : (pointwiseLeftKanExtension L F).IsLeftKanExtension
    (pointwiseLeftKanExtensionUnit L F) 
goal: (L.pointwiseLeftKanExtension F).IsLeftKanExtension (L.pointwiseLeftKanExtensionUnit F)

full_name: CategoryTheory.Functor.instHasLeftKanExtension
code: instance : HasLeftKanExtension L F 
goal: L.HasLeftKanExtension F

full_name: CategoryTheory.Functor.isPointwiseLeftKanExtensionOfIsLeftKanExtension
code: /-- If `F` admits a pointwise left Kan extension along `L`, then any left Kan extension of `F`
along `L` is a pointwise left Kan extension. -/
noncomputable def isPointwiseLeftKanExtensionOfIsLeftKanExtension (F' : D ⥤ H) (α : F ⟶ L ⋙ F')
    [F'.IsLeftKanExtension α] :
    (LeftExtension.mk _ α).IsPointwiseLeftKanExtension 
goal: (CategoryTheory.Functor.LeftExtension.mk F' α).IsPointwiseLeftKanExtension

full_name: CategoryTheory.Functor.pointwiseRightKanExtension
code: /-- The constructed pointwise right Kan extension
when `HasPointwiseRightKanExtension L F` holds. -/
@[simps]
noncomputable def pointwiseRightKanExtension : D ⥤ H 
goal: CategoryTheory.Functor D H

full_name: CategoryTheory.Functor.pointwiseRightKanExtension_map
code: /-- The constructed pointwise right Kan extension
when `HasPointwiseRightKanExtension L F` holds. -/
@[simps]
noncomputable def pointwiseRightKanExtension : D ⥤ H 
goal: (L.pointwiseRightKanExtension F).map f =
  CategoryTheory.Limits.limit.lift ((CategoryTheory.StructuredArrow.proj Y₂ L).comp F)
    { pt := CategoryTheory.Limits.limit ((CategoryTheory.StructuredArrow.proj Y₁ L).comp F),
      π :=
        {
          app := fun g =>
            CategoryTheory.Limits.limit.π ((CategoryTheory.StructuredArrow.proj Y₁ L).comp F)
              ((CategoryTheory.StructuredArrow.map f).obj g),
          naturality := ⋯ } }

full_name: CategoryTheory.Functor.pointwiseRightKanExtension_obj
code: /-- The constructed pointwise right Kan extension
when `HasPointwiseRightKanExtension L F` holds. -/
@[simps]
noncomputable def pointwiseRightKanExtension : D ⥤ H 
goal: (L.pointwiseRightKanExtension F).obj Y = CategoryTheory.Limits.limit ((CategoryTheory.StructuredArrow.proj Y L).comp F)

full_name: CategoryTheory.Functor.pointwiseRightKanExtensionCounit
code: /-- The counit of the constructed pointwise right Kan extension when
`HasPointwiseRightKanExtension L F` holds. -/
@[simps]
noncomputable def pointwiseRightKanExtensionCounit :
    L ⋙ pointwiseRightKanExtension L F ⟶ F 
goal: L.comp (L.pointwiseRightKanExtension F) ⟶ F

full_name: CategoryTheory.Functor.pointwiseRightKanExtensionCounit_app
code: /-- The counit of the constructed pointwise right Kan extension when
`HasPointwiseRightKanExtension L F` holds. -/
@[simps]
noncomputable def pointwiseRightKanExtensionCounit :
    L ⋙ pointwiseRightKanExtension L F ⟶ F 
goal: (L.pointwiseRightKanExtensionCounit F).app X =
  CategoryTheory.Limits.limit.π ((CategoryTheory.StructuredArrow.proj (L.obj X) L).comp F)
    (CategoryTheory.StructuredArrow.mk (CategoryTheory.CategoryStruct.id (L.obj X)))

full_name: CategoryTheory.Functor.pointwiseRightKanExtensionIsPointwiseRightKanExtension
code: /-- The functor `pointwiseRightKanExtension L F` is a pointwise right Kan
extension of `F` along `L`. -/
noncomputable def pointwiseRightKanExtensionIsPointwiseRightKanExtension :
    (RightExtension.mk _ (pointwiseRightKanExtensionCounit L F)).IsPointwiseRightKanExtension 
goal: (CategoryTheory.Functor.RightExtension.mk (L.pointwiseRightKanExtension F)
    (L.pointwiseRightKanExtensionCounit F)).IsPointwiseRightKanExtension

full_name: CategoryTheory.Functor.pointwiseRightKanExtensionIsUniversal
code: /-- The functor `pointwiseRightKanExtension L F` is a right Kan extension of `F` along `L`. -/
noncomputable def pointwiseRightKanExtensionIsUniversal :
    (RightExtension.mk _ (pointwiseRightKanExtensionCounit L F)).IsUniversal 
goal: CategoryTheory.CostructuredArrow.IsUniversal
  (CategoryTheory.Functor.RightExtension.mk (L.pointwiseRightKanExtension F) (L.pointwiseRightKanExtensionCounit F))

full_name: CategoryTheory.Functor.instIsRightKanExtensionPointwiseRightKanExtensionPointwiseRightKanExtensionCounit
code: instance : (pointwiseRightKanExtension L F).IsRightKanExtension
    (pointwiseRightKanExtensionCounit L F) 
goal: (L.pointwiseRightKanExtension F).IsRightKanExtension (L.pointwiseRightKanExtensionCounit F)

full_name: CategoryTheory.Functor.instHasRightKanExtension
code: instance : HasRightKanExtension L F 
goal: L.HasRightKanExtension F

full_name: CategoryTheory.Functor.isPointwiseRightKanExtensionOfIsRightKanExtension
code: /-- If `F` admits a pointwise right Kan extension along `L`, then any right Kan extension of `F`
along `L` is a pointwise right Kan extension. -/
noncomputable def isPointwiseRightKanExtensionOfIsRightKanExtension (F' : D ⥤ H) (α : L ⋙ F' ⟶ F)
    [F'.IsRightKanExtension α] :
    (RightExtension.mk _ α).IsPointwiseRightKanExtension 
goal: (CategoryTheory.Functor.RightExtension.mk F' α).IsPointwiseRightKanExtension