File: Mathlib/CategoryTheory/Sites/Plus.lean

full_name: CategoryTheory.GrothendieckTopology.diagram_obj
code: /-- The diagram whose colimit defines the values of `plus`. -/
@[simps]
def diagram (X : C) : (J.Cover X)ᵒᵖ ⥤ D 
goal: (J.diagram P X).obj S = CategoryTheory.Limits.multiequalizer ((Opposite.unop S).index P)

full_name: CategoryTheory.GrothendieckTopology.diagram
code: /-- The diagram whose colimit defines the values of `plus`. -/
@[simps]
def diagram (X : C) : (J.Cover X)ᵒᵖ ⥤ D 
goal: CategoryTheory.Functor (J.Cover X)ᵒᵖ D

full_name: CategoryTheory.GrothendieckTopology.diagram_map
code: /-- The diagram whose colimit defines the values of `plus`. -/
@[simps]
def diagram (X : C) : (J.Cover X)ᵒᵖ ⥤ D 
goal: (J.diagram P X).map f =
  CategoryTheory.Limits.Multiequalizer.lift ((Opposite.unop T).index P)
    ((fun S => CategoryTheory.Limits.multiequalizer ((Opposite.unop S).index P)) S)
    (fun I =>
      CategoryTheory.Limits.Multiequalizer.ι ((Opposite.unop S).index P)
        (CategoryTheory.GrothendieckTopology.Cover.Arrow.map I f.unop))
    ⋯

full_name: CategoryTheory.GrothendieckTopology.diagramPullback
code: /-- A helper definition used to define the morphisms for `plus`. -/
@[simps]
def diagramPullback {X Y : C} (f : X ⟶ Y) : J.diagram P Y ⟶ (J.pullback f).op ⋙ J.diagram P X 
goal: J.diagram P Y ⟶ (J.pullback f).op.comp (J.diagram P X)

full_name: CategoryTheory.GrothendieckTopology.diagramPullback_app
code: /-- A helper definition used to define the morphisms for `plus`. -/
@[simps]
def diagramPullback {X Y : C} (f : X ⟶ Y) : J.diagram P Y ⟶ (J.pullback f).op ⋙ J.diagram P X 
goal: (J.diagramPullback P f).app S =
  CategoryTheory.Limits.Multiequalizer.lift ((Opposite.unop ((J.pullback f).op.obj S)).index P) ((J.diagram P Y).obj S)
    (fun I =>
      CategoryTheory.Limits.Multiequalizer.ι ((Opposite.unop S).index P)
        (CategoryTheory.GrothendieckTopology.Cover.Arrow.base I))
    ⋯

full_name: CategoryTheory.GrothendieckTopology.diagramNatTrans
code: /-- A natural transformation `P ⟶ Q` induces a natural transformation
between diagrams whose colimits define the values of `plus`. -/
@[simps]
def diagramNatTrans {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) (X : C) : J.diagram P X ⟶ J.diagram Q X 
goal: J.diagram P X ⟶ J.diagram Q X

full_name: CategoryTheory.GrothendieckTopology.diagramNatTrans_app
code: /-- A natural transformation `P ⟶ Q` induces a natural transformation
between diagrams whose colimits define the values of `plus`. -/
@[simps]
def diagramNatTrans {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) (X : C) : J.diagram P X ⟶ J.diagram Q X 
goal: (J.diagramNatTrans η X).app W =
  CategoryTheory.Limits.Multiequalizer.lift ((Opposite.unop W).index Q) ((J.diagram P X).obj W)
    (fun i =>
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ι ((Opposite.unop W).index P) i)
        (η.app (Opposite.op i.Y)))
    ⋯

full_name: CategoryTheory.GrothendieckTopology.diagramNatTrans_id
code: @[simp]
theorem diagramNatTrans_id (X : C) (P : Cᵒᵖ ⥤ D) :
    J.diagramNatTrans (𝟙 P) X = 𝟙 (J.diagram P X) 
goal: J.diagramNatTrans (CategoryTheory.CategoryStruct.id P) X = CategoryTheory.CategoryStruct.id (J.diagram P X)

full_name: CategoryTheory.GrothendieckTopology.diagramNatTrans_zero
code: @[simp]
theorem diagramNatTrans_zero [Preadditive D] (X : C) (P Q : Cᵒᵖ ⥤ D) :
    J.diagramNatTrans (0 : P ⟶ Q) X = 0 
goal: J.diagramNatTrans 0 X = 0

full_name: CategoryTheory.GrothendieckTopology.diagramNatTrans_comp
code: @[simp]
theorem diagramNatTrans_comp {P Q R : Cᵒᵖ ⥤ D} (η : P ⟶ Q) (γ : Q ⟶ R) (X : C) :
    J.diagramNatTrans (η ≫ γ) X = J.diagramNatTrans η X ≫ J.diagramNatTrans γ X 
goal: J.diagramNatTrans (CategoryTheory.CategoryStruct.comp η γ) X =
  CategoryTheory.CategoryStruct.comp (J.diagramNatTrans η X) (J.diagramNatTrans γ X)

full_name: CategoryTheory.GrothendieckTopology.diagramFunctor
code: /-- `J.diagram P`, as a functor in `P`. -/
@[simps]
def diagramFunctor (X : C) : (Cᵒᵖ ⥤ D) ⥤ (J.Cover X)ᵒᵖ ⥤ D 
goal: CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ D) (CategoryTheory.Functor (J.Cover X)ᵒᵖ D)

full_name: CategoryTheory.GrothendieckTopology.diagramFunctor_obj
code: /-- `J.diagram P`, as a functor in `P`. -/
@[simps]
def diagramFunctor (X : C) : (Cᵒᵖ ⥤ D) ⥤ (J.Cover X)ᵒᵖ ⥤ D 
goal: (J.diagramFunctor D X).obj P = J.diagram P X

full_name: CategoryTheory.GrothendieckTopology.diagramFunctor_map
code: /-- `J.diagram P`, as a functor in `P`. -/
@[simps]
def diagramFunctor (X : C) : (Cᵒᵖ ⥤ D) ⥤ (J.Cover X)ᵒᵖ ⥤ D 
goal: ∀ {X_1 Y : CategoryTheory.Functor Cᵒᵖ D} (η : X_1 ⟶ Y), (J.diagramFunctor D X).map η = J.diagramNatTrans η X

full_name: CategoryTheory.GrothendieckTopology.plusObj
code: /-- The plus construction, associating a presheaf to any presheaf.
See `plusFunctor` below for a functorial version. -/
def plusObj : Cᵒᵖ ⥤ D 
goal: CategoryTheory.Functor Cᵒᵖ D

full_name: CategoryTheory.GrothendieckTopology.plusMap
code: /-- An auxiliary definition used in `plus` below. -/
def plusMap {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) : J.plusObj P ⟶ J.plusObj Q 
goal: J.plusObj P ⟶ J.plusObj Q

full_name: CategoryTheory.GrothendieckTopology.plusMap_id
code: @[simp]
theorem plusMap_id (P : Cᵒᵖ ⥤ D) : J.plusMap (𝟙 P) = 𝟙 _ 
goal: J.plusMap (CategoryTheory.CategoryStruct.id P) = CategoryTheory.CategoryStruct.id (J.plusObj P)

full_name: CategoryTheory.GrothendieckTopology.plusMap_zero
code: @[simp]
theorem plusMap_zero [Preadditive D] (P Q : Cᵒᵖ ⥤ D) : J.plusMap (0 : P ⟶ Q) = 0 
goal: J.plusMap 0 = 0

full_name: CategoryTheory.GrothendieckTopology.plusMap_comp
code: @[simp, reassoc]
theorem plusMap_comp {P Q R : Cᵒᵖ ⥤ D} (η : P ⟶ Q) (γ : Q ⟶ R) :
    J.plusMap (η ≫ γ) = J.plusMap η ≫ J.plusMap γ 
goal: J.plusMap (CategoryTheory.CategoryStruct.comp η γ) = CategoryTheory.CategoryStruct.comp (J.plusMap η) (J.plusMap γ)

full_name: CategoryTheory.GrothendieckTopology.plusFunctor
code: /-- The plus construction, a functor sending `P` to `J.plusObj P`. -/
@[simps]
def plusFunctor : (Cᵒᵖ ⥤ D) ⥤ Cᵒᵖ ⥤ D 
goal: CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ D) (CategoryTheory.Functor Cᵒᵖ D)

full_name: CategoryTheory.GrothendieckTopology.plusFunctor_obj
code: /-- The plus construction, a functor sending `P` to `J.plusObj P`. -/
@[simps]
def plusFunctor : (Cᵒᵖ ⥤ D) ⥤ Cᵒᵖ ⥤ D 
goal: (J.plusFunctor D).obj P = J.plusObj P

full_name: CategoryTheory.GrothendieckTopology.plusFunctor_map
code: /-- The plus construction, a functor sending `P` to `J.plusObj P`. -/
@[simps]
def plusFunctor : (Cᵒᵖ ⥤ D) ⥤ Cᵒᵖ ⥤ D 
goal: ∀ {X Y : CategoryTheory.Functor Cᵒᵖ D} (η : X ⟶ Y), (J.plusFunctor D).map η = J.plusMap η

full_name: CategoryTheory.GrothendieckTopology.toPlus
code: /-- The canonical map from `P` to `J.plusObj P`.
See `toPlusNatTrans` for a functorial version. -/
def toPlus : P ⟶ J.plusObj P 
goal: P ⟶ J.plusObj P

full_name: CategoryTheory.GrothendieckTopology.toPlus_naturality
code: @[reassoc (attr := simp)]
theorem toPlus_naturality {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) :
    η ≫ J.toPlus Q = J.toPlus _ ≫ J.plusMap η 
goal: CategoryTheory.CategoryStruct.comp η (J.toPlus Q) = CategoryTheory.CategoryStruct.comp (J.toPlus P) (J.plusMap η)

full_name: CategoryTheory.GrothendieckTopology.toPlusNatTrans_app
code: /-- The natural transformation from the identity functor to `plus`. -/
@[simps]
def toPlusNatTrans : 𝟭 (Cᵒᵖ ⥤ D) ⟶ J.plusFunctor D 
goal: (J.toPlusNatTrans D).app P = J.toPlus P

full_name: CategoryTheory.GrothendieckTopology.toPlusNatTrans
code: /-- The natural transformation from the identity functor to `plus`. -/
@[simps]
def toPlusNatTrans : 𝟭 (Cᵒᵖ ⥤ D) ⟶ J.plusFunctor D 
goal: CategoryTheory.Functor.id (CategoryTheory.Functor Cᵒᵖ D) ⟶ J.plusFunctor D

full_name: CategoryTheory.GrothendieckTopology.plusMap_toPlus
code: /-- `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺` -/
@[simp]
theorem plusMap_toPlus : J.plusMap (J.toPlus P) = J.toPlus (J.plusObj P) 
goal: J.plusMap (J.toPlus P) = J.toPlus (J.plusObj P)

full_name: CategoryTheory.GrothendieckTopology.isIso_toPlus_of_isSheaf
code: theorem isIso_toPlus_of_isSheaf (hP : Presheaf.IsSheaf J P) : IsIso (J.toPlus P) 
goal: CategoryTheory.IsIso (J.toPlus P)

full_name: CategoryTheory.GrothendieckTopology.isoToPlus
code: /-- The natural isomorphism between `P` and `P⁺` when `P` is a sheaf. -/
def isoToPlus (hP : Presheaf.IsSheaf J P) : P ≅ J.plusObj P 
goal: P ≅ J.plusObj P

full_name: CategoryTheory.GrothendieckTopology.isoToPlus_hom
code: @[simp]
theorem isoToPlus_hom (hP : Presheaf.IsSheaf J P) : (J.isoToPlus P hP).hom = J.toPlus P 
goal: (J.isoToPlus P hP).hom = J.toPlus P

full_name: CategoryTheory.GrothendieckTopology.plusLift
code: /-- Lift a morphism `P ⟶ Q` to `P⁺ ⟶ Q` when `Q` is a sheaf. -/
def plusLift {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) (hQ : Presheaf.IsSheaf J Q) : J.plusObj P ⟶ Q 
goal: J.plusObj P ⟶ Q

full_name: CategoryTheory.GrothendieckTopology.toPlus_plusLift
code: @[reassoc (attr := simp)]
theorem toPlus_plusLift {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) (hQ : Presheaf.IsSheaf J Q) :
    J.toPlus P ≫ J.plusLift η hQ = η 
goal: CategoryTheory.CategoryStruct.comp (J.toPlus P) (J.plusLift η hQ) = η

full_name: CategoryTheory.GrothendieckTopology.plusLift_unique
code: theorem plusLift_unique {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) (hQ : Presheaf.IsSheaf J Q)
    (γ : J.plusObj P ⟶ Q) (hγ : J.toPlus P ≫ γ = η) : γ = J.plusLift η hQ 
goal: γ = J.plusLift η hQ

full_name: CategoryTheory.GrothendieckTopology.plus_hom_ext
code: theorem plus_hom_ext {P Q : Cᵒᵖ ⥤ D} (η γ : J.plusObj P ⟶ Q) (hQ : Presheaf.IsSheaf J Q)
    (h : J.toPlus P ≫ η = J.toPlus P ≫ γ) : η = γ 
goal: η = γ

full_name: CategoryTheory.GrothendieckTopology.isoToPlus_inv
code: @[simp]
theorem isoToPlus_inv (hP : Presheaf.IsSheaf J P) :
    (J.isoToPlus P hP).inv = J.plusLift (𝟙 _) hP 
goal: (J.isoToPlus P hP).inv = J.plusLift (CategoryTheory.CategoryStruct.id P) hP

full_name: CategoryTheory.GrothendieckTopology.plusMap_plusLift
code: @[simp]
theorem plusMap_plusLift {P Q R : Cᵒᵖ ⥤ D} (η : P ⟶ Q) (γ : Q ⟶ R) (hR : Presheaf.IsSheaf J R) :
    J.plusMap η ≫ J.plusLift γ hR = J.plusLift (η ≫ γ) hR 
goal: CategoryTheory.CategoryStruct.comp (J.plusMap η) (J.plusLift γ hR) =
  J.plusLift (CategoryTheory.CategoryStruct.comp η γ) hR

full_name: CategoryTheory.GrothendieckTopology.plusFunctor_preservesZeroMorphisms
code: instance plusFunctor_preservesZeroMorphisms [Preadditive D] :
    (plusFunctor J D).PreservesZeroMorphisms 
goal: (J.plusFunctor D).PreservesZeroMorphisms