File: Mathlib/CategoryTheory/Sites/Adjunction.lean

full_name: CategoryTheory.sheafForget
code: /-- The forgetful functor from `Sheaf J D` to sheaves of types, for a concrete category `D`
whose forgetful functor preserves the correct limits. -/
abbrev sheafForget [ConcreteCategory D] [HasSheafCompose J (forget D)] :
    Sheaf J D ⥤ SheafOfTypes J 
goal: CategoryTheory.Functor (CategoryTheory.Sheaf J D) (CategoryTheory.SheafOfTypes J)

full_name: CategoryTheory.Sheaf.composeEquiv_apply_val
code: /-- An auxiliary definition to be used in defining `CategoryTheory.Sheaf.adjunction` below. -/
@[simps]
def composeEquiv [HasSheafCompose J F] (adj : G ⊣ F) (X : Sheaf J E) (Y : Sheaf J D) :
    ((composeAndSheafify J G).obj X ⟶ Y) ≃ (X ⟶ (sheafCompose J F).obj Y) 
goal: ((CategoryTheory.Sheaf.composeEquiv J adj X Y) η).val =
  ((CategoryTheory.Adjunction.whiskerRight Cᵒᵖ adj).homEquiv X.val Y.val)
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.toSheafify J (((CategoryTheory.whiskeringRight Cᵒᵖ E D).obj G).obj X.val)) η.val)

full_name: CategoryTheory.Sheaf.composeEquiv_symm_apply_val
code: /-- An auxiliary definition to be used in defining `CategoryTheory.Sheaf.adjunction` below. -/
@[simps]
def composeEquiv [HasSheafCompose J F] (adj : G ⊣ F) (X : Sheaf J E) (Y : Sheaf J D) :
    ((composeAndSheafify J G).obj X ⟶ Y) ≃ (X ⟶ (sheafCompose J F).obj Y) 
goal: ((CategoryTheory.Sheaf.composeEquiv J adj X Y).symm γ).val =
  CategoryTheory.sheafifyLift J
    (((CategoryTheory.Adjunction.whiskerRight Cᵒᵖ adj).homEquiv ((CategoryTheory.sheafToPresheaf J E).obj X) Y.val).symm
      ((CategoryTheory.sheafToPresheaf J E).map γ))
    ⋯

full_name: CategoryTheory.Sheaf.composeEquiv
code: /-- An auxiliary definition to be used in defining `CategoryTheory.Sheaf.adjunction` below. -/
@[simps]
def composeEquiv [HasSheafCompose J F] (adj : G ⊣ F) (X : Sheaf J E) (Y : Sheaf J D) :
    ((composeAndSheafify J G).obj X ⟶ Y) ≃ (X ⟶ (sheafCompose J F).obj Y) 
goal: ((CategoryTheory.Sheaf.composeAndSheafify J G).obj X ⟶ Y) ≃ (X ⟶ (CategoryTheory.sheafCompose J F).obj Y)

full_name: CategoryTheory.Sheaf.adjunction
code: /-- An adjunction `adj : G ⊣ F` with `F : D ⥤ E` and `G : E ⥤ D` induces an adjunction
between `Sheaf J D` and `Sheaf J E`, in contexts where one can sheafify `D`-valued presheaves,
and `F` preserves the correct limits. -/
@[simps! unit_app_val counit_app_val]
def adjunction [HasSheafCompose J F] (adj : G ⊣ F) :
    composeAndSheafify J G ⊣ sheafCompose J F 
goal: CategoryTheory.Sheaf.composeAndSheafify J G ⊣ CategoryTheory.sheafCompose J F

full_name: CategoryTheory.Sheaf.adjunction_unit_app_val
code: /-- An adjunction `adj : G ⊣ F` with `F : D ⥤ E` and `G : E ⥤ D` induces an adjunction
between `Sheaf J D` and `Sheaf J E`, in contexts where one can sheafify `D`-valued presheaves,
and `F` preserves the correct limits. -/
@[simps! unit_app_val counit_app_val]
def adjunction [HasSheafCompose J F] (adj : G ⊣ F) :
    composeAndSheafify J G ⊣ sheafCompose J F 
goal: ((CategoryTheory.Sheaf.adjunction J adj).unit.app X).val =
  ((CategoryTheory.Adjunction.whiskerRight Cᵒᵖ adj).homEquiv X.val
      ((CategoryTheory.presheafToSheaf J D).obj (X.val.comp G)).val)
    (CategoryTheory.toSheafify J (X.val.comp G))

full_name: CategoryTheory.Sheaf.adjunction_counit_app_val
code: /-- An adjunction `adj : G ⊣ F` with `F : D ⥤ E` and `G : E ⥤ D` induces an adjunction
between `Sheaf J D` and `Sheaf J E`, in contexts where one can sheafify `D`-valued presheaves,
and `F` preserves the correct limits. -/
@[simps! unit_app_val counit_app_val]
def adjunction [HasSheafCompose J F] (adj : G ⊣ F) :
    composeAndSheafify J G ⊣ sheafCompose J F 
goal: ((CategoryTheory.Sheaf.adjunction J adj).counit.app Y).val =
  CategoryTheory.sheafifyLift J
    (((CategoryTheory.Adjunction.whiskerRight Cᵒᵖ adj).homEquiv (Y.val.comp F) Y.val).symm
      (CategoryTheory.CategoryStruct.id (Y.val.comp F)))
    ⋯

full_name: CategoryTheory.Sheaf.instIsRightAdjointSheafCompose
code: instance [F.IsRightAdjoint] : (sheafCompose J F).IsRightAdjoint 
goal: (CategoryTheory.sheafCompose J F).IsRightAdjoint

full_name: CategoryTheory.Sheaf.instIsLeftAdjointComposeAndSheafify
code: instance [G.IsLeftAdjoint] : (composeAndSheafify J G).IsLeftAdjoint 
goal: (CategoryTheory.Sheaf.composeAndSheafify J G).IsLeftAdjoint

full_name: CategoryTheory.Sheaf.preservesSheafification_of_adjunction
code: lemma preservesSheafification_of_adjunction (adj : G ⊣ F) :
    J.PreservesSheafification G 
goal: J.PreservesSheafification G

full_name: CategoryTheory.Sheaf.instPreservesSheafificationOfIsLeftAdjoint
code: instance [G.IsLeftAdjoint] : J.PreservesSheafification G 
goal: J.PreservesSheafification G

full_name: CategoryTheory.Sheaf.composeAndSheafifyFromTypes
code: /-- This is the functor sending a sheaf of types `X` to the sheafification of `X ⋙ G`. -/
abbrev composeAndSheafifyFromTypes (G : Type max v₁ u₁ ⥤ D) : SheafOfTypes J ⥤ Sheaf J D 
goal: CategoryTheory.Functor (CategoryTheory.SheafOfTypes J) (CategoryTheory.Sheaf J D)

full_name: CategoryTheory.Sheaf.adjunctionToTypes
code: /-- A variant of the adjunction between sheaf categories, in the case where the right adjoint
is the forgetful functor to sheaves of types. -/
def adjunctionToTypes {G : Type max v₁ u₁ ⥤ D} (adj : G ⊣ forget D) :
    composeAndSheafifyFromTypes J G ⊣ sheafForget J 
goal: CategoryTheory.Sheaf.composeAndSheafifyFromTypes J G ⊣ CategoryTheory.sheafForget J

full_name: CategoryTheory.Sheaf.adjunctionToTypes_unit_app_val
code: @[simp]
theorem adjunctionToTypes_unit_app_val {G : Type max v₁ u₁ ⥤ D} (adj : G ⊣ forget D)
    (Y : SheafOfTypes J) :
    ((adjunctionToTypes J adj).unit.app Y).val =
      (adj.whiskerRight _).unit.app ((sheafOfTypesToPresheaf J).obj Y) ≫
        whiskerRight (toSheafify J _) (forget D) 
goal: ((CategoryTheory.Sheaf.adjunctionToTypes J adj).unit.app Y).val =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.Adjunction.whiskerRight Cᵒᵖ adj).unit.app ((CategoryTheory.sheafOfTypesToPresheaf J).obj Y))
    (CategoryTheory.whiskerRight
      (CategoryTheory.toSheafify J
        (((CategoryTheory.whiskeringRight Cᵒᵖ (Type (max v₁ u₁)) D).obj G).obj
          ((CategoryTheory.sheafOfTypesToPresheaf J).obj Y)))
      (CategoryTheory.forget D))

full_name: CategoryTheory.Sheaf.adjunctionToTypes_counit_app_val
code: @[simp]
theorem adjunctionToTypes_counit_app_val {G : Type max v₁ u₁ ⥤ D} (adj : G ⊣ forget D)
    (X : Sheaf J D) :
    ((adjunctionToTypes J adj).counit.app X).val =
      sheafifyLift J ((Functor.associator _ _ _).hom ≫ (adj.whiskerRight _).counit.app _) X.2 
goal: ((CategoryTheory.Sheaf.adjunctionToTypes J adj).counit.app X).val =
  CategoryTheory.sheafifyLift J
    (CategoryTheory.CategoryStruct.comp (X.1.associator (CategoryTheory.forget D) G).hom
      ((CategoryTheory.Adjunction.whiskerRight Cᵒᵖ adj).counit.app X.1))
    ⋯

full_name: CategoryTheory.Sheaf.instIsRightAdjointSheafOfTypesSheafForgetOfForget
code: instance [(forget D).IsRightAdjoint] :
    (sheafForget.{_, _, _, _, max u₁ v₁} (D := D) J).IsRightAdjoint 
goal: (CategoryTheory.sheafForget J).IsRightAdjoint