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

full_name: CategoryTheory.Functor.lan
code: /-- The left Kan extension functor `(C ⥤ H) ⥤ (D ⥤ H)` along a functor `C ⥤ D`. -/
noncomputable def lan : (C ⥤ H) ⥤ (D ⥤ H) 
goal: CategoryTheory.Functor (CategoryTheory.Functor C H) (CategoryTheory.Functor D H)

full_name: CategoryTheory.Functor.lanUnit
code: /-- The natural transformation `F ⟶ L ⋙ (L.lan).obj G`. -/
noncomputable def lanUnit : (𝟭 (C ⥤ H)) ⟶ L.lan ⋙ (whiskeringLeft C D H).obj L 
goal: CategoryTheory.Functor.id (CategoryTheory.Functor C H) ⟶ L.lan.comp ((CategoryTheory.whiskeringLeft C D H).obj L)

full_name: CategoryTheory.Functor.instIsLeftKanExtensionObjLanAppLanUnit
code: instance (F : C ⥤ H) : (L.lan.obj F).IsLeftKanExtension (L.lanUnit.app F) 
goal: (L.lan.obj F).IsLeftKanExtension (L.lanUnit.app F)

full_name: CategoryTheory.Functor.isPointwiseLeftKanExtensionLanUnit
code: /-- If there exists a pointwise left Kan extension of `F` along `L`,
then `L.lan.obj G` is a pointwise left Kan extension of `F`. -/
noncomputable def isPointwiseLeftKanExtensionLanUnit
    (F : C ⥤ H) [HasPointwiseLeftKanExtension L F] :
    (LeftExtension.mk _ (L.lanUnit.app F)).IsPointwiseLeftKanExtension 
goal: (CategoryTheory.Functor.LeftExtension.mk (L.lan.obj F) (L.lanUnit.app F)).IsPointwiseLeftKanExtension

full_name: CategoryTheory.Functor.lanAdjunction
code: /-- The left Kan extension functor `L.Lan` is left adjoint to the
precomposition by `L`. -/
noncomputable def lanAdjunction : L.lan ⊣ (whiskeringLeft C D H).obj L 
goal: L.lan ⊣ (CategoryTheory.whiskeringLeft C D H).obj L

full_name: CategoryTheory.Functor.lanAdjunction_unit
code: @[simp]
lemma lanAdjunction_unit : (L.lanAdjunction H).unit = L.lanUnit 
goal: (L.lanAdjunction H).unit = L.lanUnit

full_name: CategoryTheory.Functor.lanAdjunction_counit_app
code: lemma lanAdjunction_counit_app (G : D ⥤ H) :
    (L.lanAdjunction H).counit.app G =
      descOfIsLeftKanExtension (L.lan.obj (L ⋙ G)) (L.lanUnit.app (L ⋙ G)) G (𝟙 (L ⋙ G)) 
goal: (L.lanAdjunction H).counit.app G =
  (L.lan.obj (L.comp G)).descOfIsLeftKanExtension (L.lanUnit.app (L.comp G)) G
    (CategoryTheory.CategoryStruct.id (L.comp G))

full_name: CategoryTheory.Functor.lanUnit_app_whiskerLeft_lanAdjunction_counit_app
code: @[reassoc (attr := simp)]
lemma lanUnit_app_whiskerLeft_lanAdjunction_counit_app (G : D ⥤ H) :
    L.lanUnit.app (L ⋙ G) ≫ whiskerLeft L ((L.lanAdjunction H).counit.app G) = 𝟙 (L ⋙ G) 
goal: CategoryTheory.CategoryStruct.comp (L.lanUnit.app (L.comp G))
    (CategoryTheory.whiskerLeft L ((L.lanAdjunction H).counit.app G)) =
  CategoryTheory.CategoryStruct.id (L.comp G)

full_name: CategoryTheory.Functor.lanUnit_app_app_lanAdjunction_counit_app_app
code: @[reassoc (attr := simp)]
lemma lanUnit_app_app_lanAdjunction_counit_app_app (G : D ⥤ H) (X : C) :
    (L.lanUnit.app (L ⋙ G)).app X ≫ ((L.lanAdjunction H).counit.app G).app (L.obj X) = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp ((L.lanUnit.app (L.comp G)).app X)
    (((L.lanAdjunction H).counit.app G).app (L.obj X)) =
  CategoryTheory.CategoryStruct.id (((CategoryTheory.Functor.id (CategoryTheory.Functor C H)).obj (L.comp G)).obj X)

full_name: CategoryTheory.Functor.isIso_lanAdjunction_counit_app_iff
code: lemma isIso_lanAdjunction_counit_app_iff (G : D ⥤ H) :
    IsIso ((L.lanAdjunction H).counit.app G) ↔ G.IsLeftKanExtension (𝟙 (L ⋙ G)) 
goal: CategoryTheory.IsIso ((L.lanAdjunction H).counit.app G) ↔
  G.IsLeftKanExtension (CategoryTheory.CategoryStruct.id (L.comp G))

full_name: CategoryTheory.Functor.instIsIsoAppLanUnit
code: instance (F : C ⥤ H) (X : C) [HasPointwiseLeftKanExtension L F]
    [∀ (F : C ⥤ H), HasLeftKanExtension L F] :
    IsIso ((L.lanUnit.app F).app X) 
goal: CategoryTheory.IsIso ((L.lanUnit.app F).app X)

full_name: CategoryTheory.Functor.instIsIsoAppLanUnit_1
code: instance (F : C ⥤ H) [HasPointwiseLeftKanExtension L F]
    [∀ (F : C ⥤ H), HasLeftKanExtension L F] :
    IsIso (L.lanUnit.app F) 
goal: CategoryTheory.IsIso (L.lanUnit.app F)

full_name: CategoryTheory.Functor.coreflective
code: instance coreflective [∀ (F : C ⥤ H), HasPointwiseLeftKanExtension L F] :
    IsIso (L.lanUnit (H := H)) 
goal: CategoryTheory.IsIso L.lanUnit

full_name: CategoryTheory.Functor.instIsIsoAppUnitLanAdjunctionOfHasPointwiseLeftKanExtension
code: instance (F : C ⥤ H) [HasPointwiseLeftKanExtension L F]
    [∀ (F : C ⥤ H), HasLeftKanExtension L F] :
    IsIso ((L.lanAdjunction H).unit.app F) 
goal: CategoryTheory.IsIso ((L.lanAdjunction H).unit.app F)

full_name: CategoryTheory.Functor.coreflective'
code: instance coreflective' [∀ (F : C ⥤ H), HasPointwiseLeftKanExtension L F] :
    IsIso (L.lanAdjunction H).unit 
goal: CategoryTheory.IsIso (L.lanAdjunction H).unit

full_name: CategoryTheory.Functor.ran
code: /-- The right Kan extension functor `(C ⥤ H) ⥤ (D ⥤ H)` along a functor `C ⥤ D`. -/
noncomputable def ran : (C ⥤ H) ⥤ (D ⥤ H) 
goal: CategoryTheory.Functor (CategoryTheory.Functor C H) (CategoryTheory.Functor D H)

full_name: CategoryTheory.Functor.ranCounit
code: /-- The natural transformation `L ⋙ (L.lan).obj G ⟶ L`. -/
noncomputable def ranCounit : L.ran ⋙ (whiskeringLeft C D H).obj L ⟶ (𝟭 (C ⥤ H)) 
goal: L.ran.comp ((CategoryTheory.whiskeringLeft C D H).obj L) ⟶ CategoryTheory.Functor.id (CategoryTheory.Functor C H)

full_name: CategoryTheory.Functor.instIsRightKanExtensionObjRanAppRanCounit
code: instance (F : C ⥤ H) : (L.ran.obj F).IsRightKanExtension (L.ranCounit.app F) 
goal: (L.ran.obj F).IsRightKanExtension (L.ranCounit.app F)

full_name: CategoryTheory.Functor.isPointwiseRightKanExtensionRanCounit
code: /-- If there exists a pointwise right Kan extension of `F` along `L`,
then `L.ran.obj G` is a pointwise right Kan extension of `F`. -/
noncomputable def isPointwiseRightKanExtensionRanCounit
    (F : C ⥤ H) [HasPointwiseRightKanExtension L F] :
    (RightExtension.mk _ (L.ranCounit.app F)).IsPointwiseRightKanExtension 
goal: (CategoryTheory.Functor.RightExtension.mk (L.ran.obj F) (L.ranCounit.app F)).IsPointwiseRightKanExtension

full_name: CategoryTheory.Functor.ranAdjunction
code: /-- The right Kan extension functor `L.ran` is right adjoint to the
precomposition by `L`. -/
noncomputable def ranAdjunction : (whiskeringLeft C D H).obj L ⊣ L.ran 
goal: (CategoryTheory.whiskeringLeft C D H).obj L ⊣ L.ran

full_name: CategoryTheory.Functor.ranAdjunction_counit
code: @[simp]
lemma ranAdjunction_counit : (L.ranAdjunction H).counit = L.ranCounit 
goal: (L.ranAdjunction H).counit = L.ranCounit

full_name: CategoryTheory.Functor.ranAdjunction_unit_app
code: lemma ranAdjunction_unit_app (G : D ⥤ H) :
    (L.ranAdjunction H).unit.app G =
      liftOfIsRightKanExtension (L.ran.obj (L ⋙ G)) (L.ranCounit.app (L ⋙ G)) G (𝟙 (L ⋙ G)) 
goal: (L.ranAdjunction H).unit.app G =
  (L.ran.obj (L.comp G)).liftOfIsRightKanExtension (L.ranCounit.app (L.comp G)) G
    (CategoryTheory.CategoryStruct.id (L.comp G))

full_name: CategoryTheory.Functor.ranCounit_app_whiskerLeft_ranAdjunction_unit_app
code: @[reassoc (attr := simp)]
lemma ranCounit_app_whiskerLeft_ranAdjunction_unit_app (G : D ⥤ H) :
    whiskerLeft L ((L.ranAdjunction H).unit.app G) ≫ L.ranCounit.app (L ⋙ G) = 𝟙 (L ⋙ G) 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerLeft L ((L.ranAdjunction H).unit.app G))
    (L.ranCounit.app (L.comp G)) =
  CategoryTheory.CategoryStruct.id (L.comp G)

full_name: CategoryTheory.Functor.ranCounit_app_app_ranAdjunction_unit_app_app
code: @[reassoc (attr := simp)]
lemma ranCounit_app_app_ranAdjunction_unit_app_app (G : D ⥤ H) (X : C) :
    ((L.ranAdjunction H).unit.app G).app (L.obj X) ≫ (L.ranCounit.app (L ⋙ G)).app X = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (((L.ranAdjunction H).unit.app G).app (L.obj X))
    ((L.ranCounit.app (L.comp G)).app X) =
  CategoryTheory.CategoryStruct.id (((CategoryTheory.Functor.id (CategoryTheory.Functor D H)).obj G).obj (L.obj X))

full_name: CategoryTheory.Functor.isIso_ranAdjunction_unit_app_iff
code: lemma isIso_ranAdjunction_unit_app_iff (G : D ⥤ H) :
    IsIso ((L.ranAdjunction H).unit.app G) ↔ G.IsRightKanExtension (𝟙 (L ⋙ G)) 
goal: CategoryTheory.IsIso ((L.ranAdjunction H).unit.app G) ↔
  G.IsRightKanExtension (CategoryTheory.CategoryStruct.id (L.comp G))

full_name: CategoryTheory.Functor.instIsIsoAppRanCounit
code: instance (F : C ⥤ H) (X : C) [HasPointwiseRightKanExtension L F]
    [∀ (F : C ⥤ H), HasRightKanExtension L F] :
    IsIso ((L.ranCounit.app F).app X) 
goal: CategoryTheory.IsIso ((L.ranCounit.app F).app X)

full_name: CategoryTheory.Functor.instIsIsoAppRanCounit_1
code: instance (F : C ⥤ H) [HasPointwiseRightKanExtension L F]
    [∀ (F : C ⥤ H), HasRightKanExtension L F] :
    IsIso (L.ranCounit.app F) 
goal: CategoryTheory.IsIso (L.ranCounit.app F)

full_name: CategoryTheory.Functor.reflective
code: instance reflective [∀ (F : C ⥤ H), HasPointwiseRightKanExtension L F] :
    IsIso (L.ranCounit (H := H)) 
goal: CategoryTheory.IsIso L.ranCounit

full_name: CategoryTheory.Functor.instIsIsoAppCounitRanAdjunctionOfHasPointwiseRightKanExtension
code: instance (F : C ⥤ H) [HasPointwiseRightKanExtension L F]
    [∀ (F : C ⥤ H), HasRightKanExtension L F] :
    IsIso ((L.ranAdjunction H).counit.app F) 
goal: CategoryTheory.IsIso ((L.ranAdjunction H).counit.app F)

full_name: CategoryTheory.Functor.reflective'
code: instance reflective' [∀ (F : C ⥤ H), HasPointwiseRightKanExtension L F] :
    IsIso (L.ranAdjunction H).counit 
goal: CategoryTheory.IsIso (L.ranAdjunction H).counit