File: Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean

full_name: CategoryTheory.Meq
code: /-- A concrete version of the multiequalizer, to be used below. -/
def Meq {X : C} (P : Cᵒᵖ ⥤ D) (S : J.Cover X) 
goal: Type (max 0 u v)

full_name: CategoryTheory.Meq.instCoeFunForallObjForgetOppositeOpY
code: instance {X} (P : Cᵒᵖ ⥤ D) (S : J.Cover X) :
    CoeFun (Meq P S) fun _ => ∀ I : S.Arrow, P.obj (op I.Y) 
goal: CoeFun (CategoryTheory.Meq P S) fun x => (I : S.Arrow) → (CategoryTheory.forget D).obj (P.obj (Opposite.op I.Y))

full_name: CategoryTheory.Meq.congr_apply
code: lemma congr_apply {X} {P : Cᵒᵖ ⥤ D} {S : J.Cover X} (x : Meq P S) {Y}
    {f g : Y ⟶ X} (h : f = g) (hf : S f) :
    x ⟨_, _, hf⟩ = x ⟨_, g, by simpa only [← h] using hf⟩ 
goal: ↑x { Y := Y, f := f, hf := hf } = ↑x { Y := Y, f := g, hf := ⋯ }

full_name: CategoryTheory.Meq.ext
code: @[ext]
theorem ext {X} {P : Cᵒᵖ ⥤ D} {S : J.Cover X} (x y : Meq P S) (h : ∀ I : S.Arrow, x I = y I) :
    x = y 
goal: x = y

full_name: CategoryTheory.Meq.condition
code: theorem condition {X} {P : Cᵒᵖ ⥤ D} {S : J.Cover X} (x : Meq P S) (I : S.Relation) :
    P.map I.r.g₁.op (x ((S.index P).fstTo I)) = P.map I.r.g₂.op (x ((S.index P).sndTo I)) 
goal: (P.map I.r.g₁.op) (↑x ((S.index P).fstTo I)) = (P.map I.r.g₂.op) (↑x ((S.index P).sndTo I))

full_name: CategoryTheory.Meq.refine
code: /-- Refine a term of `Meq P T` with respect to a refinement `S ⟶ T` of covers. -/
def refine {X : C} {P : Cᵒᵖ ⥤ D} {S T : J.Cover X} (x : Meq P T) (e : S ⟶ T) : Meq P S 
goal: CategoryTheory.Meq P S

full_name: CategoryTheory.Meq.refine_apply
code: @[simp]
theorem refine_apply {X : C} {P : Cᵒᵖ ⥤ D} {S T : J.Cover X} (x : Meq P T) (e : S ⟶ T)
    (I : S.Arrow) : x.refine e I = x ⟨I.Y, I.f, (leOfHom e) _ I.hf⟩ 
goal: ↑(x.refine e) I = ↑x { Y := I.Y, f := I.f, hf := ⋯ }

full_name: CategoryTheory.Meq.pullback
code: /-- Pull back a term of `Meq P S` with respect to a morphism `f : Y ⟶ X` in `C`. -/
def pullback {Y X : C} {P : Cᵒᵖ ⥤ D} {S : J.Cover X} (x : Meq P S) (f : Y ⟶ X) :
    Meq P ((J.pullback f).obj S) 
goal: CategoryTheory.Meq P ((J.pullback f).obj S)

full_name: CategoryTheory.Meq.pullback_apply
code: @[simp]
theorem pullback_apply {Y X : C} {P : Cᵒᵖ ⥤ D} {S : J.Cover X} (x : Meq P S) (f : Y ⟶ X)
    (I : ((J.pullback f).obj S).Arrow) : x.pullback f I = x ⟨_, I.f ≫ f, I.hf⟩ 
goal: ↑(x.pullback f) I = ↑x { Y := I.Y, f := CategoryTheory.CategoryStruct.comp I.f f, hf := ⋯ }

full_name: CategoryTheory.Meq.pullback_refine
code: @[simp]
theorem pullback_refine {Y X : C} {P : Cᵒᵖ ⥤ D} {S T : J.Cover X} (h : S ⟶ T) (f : Y ⟶ X)
    (x : Meq P T) : (x.pullback f).refine ((J.pullback f).map h) = (refine x h).pullback _ 
goal: (x.pullback f).refine ((J.pullback f).map h) = (x.refine h).pullback f

full_name: CategoryTheory.Meq.mk
code: /-- Make a term of `Meq P S`. -/
def mk {X : C} {P : Cᵒᵖ ⥤ D} (S : J.Cover X) (x : P.obj (op X)) : Meq P S 
goal: CategoryTheory.Meq P S

full_name: CategoryTheory.Meq.mk_apply
code: theorem mk_apply {X : C} {P : Cᵒᵖ ⥤ D} (S : J.Cover X) (x : P.obj (op X)) (I : S.Arrow) :
    mk S x I = P.map I.f.op x 
goal: ↑(CategoryTheory.Meq.mk S x) I = (P.map I.f.op) x

full_name: CategoryTheory.Meq.equiv
code: /-- The equivalence between the type associated to `multiequalizer (S.index P)` and `Meq P S`. -/
noncomputable def equiv {X : C} (P : Cᵒᵖ ⥤ D) (S : J.Cover X) [HasMultiequalizer (S.index P)] :
    (multiequalizer (S.index P) : D) ≃ Meq P S 
goal: (CategoryTheory.forget D).obj (CategoryTheory.Limits.multiequalizer (S.index P)) ≃ CategoryTheory.Meq P S

full_name: CategoryTheory.Meq.equiv_apply
code: @[simp]
theorem equiv_apply {X : C} {P : Cᵒᵖ ⥤ D} {S : J.Cover X} [HasMultiequalizer (S.index P)]
    (x : (multiequalizer (S.index P) : D)) (I : S.Arrow) :
    equiv P S x I = Multiequalizer.ι (S.index P) I x 
goal: ↑((CategoryTheory.Meq.equiv P S) x) I = (CategoryTheory.Limits.Multiequalizer.ι (S.index P) I) x

full_name: CategoryTheory.Meq.equiv_symm_eq_apply
code: theorem equiv_symm_eq_apply {X : C} {P : Cᵒᵖ ⥤ D} {S : J.Cover X} [HasMultiequalizer (S.index P)]
    (x : Meq P S) (I : S.Arrow) :
    Multiequalizer.ι (S.index P) I ((Meq.equiv P S).symm x) = x I 
goal: (CategoryTheory.Limits.Multiequalizer.ι (S.index P) I) ((CategoryTheory.Meq.equiv P S).symm x) = ↑x I

full_name: CategoryTheory.GrothendieckTopology.Plus.mk
code: /-- Make a term of `(J.plusObj P).obj (op X)` from `x : Meq P S`. -/
def mk {X : C} {P : Cᵒᵖ ⥤ D} {S : J.Cover X} (x : Meq P S) : (J.plusObj P).obj (op X) 
goal: (CategoryTheory.forget D).obj ((J.plusObj P).obj (Opposite.op X))

full_name: CategoryTheory.GrothendieckTopology.Plus.res_mk_eq_mk_pullback
code: theorem res_mk_eq_mk_pullback {Y X : C} {P : Cᵒᵖ ⥤ D} {S : J.Cover X} (x : Meq P S) (f : Y ⟶ X) :
    (J.plusObj P).map f.op (mk x) = mk (x.pullback f) 
goal: ((J.plusObj P).map f.op) (CategoryTheory.GrothendieckTopology.Plus.mk x) =
  CategoryTheory.GrothendieckTopology.Plus.mk (x.pullback f)

full_name: CategoryTheory.GrothendieckTopology.Plus.toPlus_mk
code: theorem toPlus_mk {X : C} {P : Cᵒᵖ ⥤ D} (S : J.Cover X) (x : P.obj (op X)) :
    (J.toPlus P).app _ x = mk (Meq.mk S x) 
goal: ((J.toPlus P).app (Opposite.op X)) x = CategoryTheory.GrothendieckTopology.Plus.mk (CategoryTheory.Meq.mk S x)

full_name: CategoryTheory.GrothendieckTopology.Plus.toPlus_apply
code: theorem toPlus_apply {X : C} {P : Cᵒᵖ ⥤ D} (S : J.Cover X) (x : Meq P S) (I : S.Arrow) :
    (J.toPlus P).app _ (x I) = (J.plusObj P).map I.f.op (mk x) 
goal: ((J.toPlus P).app (Opposite.op I.Y)) (↑x I) = ((J.plusObj P).map I.f.op) (CategoryTheory.GrothendieckTopology.Plus.mk x)

full_name: CategoryTheory.GrothendieckTopology.Plus.toPlus_eq_mk
code: theorem toPlus_eq_mk {X : C} {P : Cᵒᵖ ⥤ D} (x : P.obj (op X)) :
    (J.toPlus P).app _ x = mk (Meq.mk ⊤ x) 
goal: ((J.toPlus P).app (Opposite.op X)) x = CategoryTheory.GrothendieckTopology.Plus.mk (CategoryTheory.Meq.mk ⊤ x)

full_name: CategoryTheory.GrothendieckTopology.Plus.exists_rep
code: theorem exists_rep {X : C} {P : Cᵒᵖ ⥤ D} (x : (J.plusObj P).obj (op X)) :
    ∃ (S : J.Cover X) (y : Meq P S), x = mk y 
goal: ∃ S y, x = CategoryTheory.GrothendieckTopology.Plus.mk y

full_name: CategoryTheory.GrothendieckTopology.Plus.eq_mk_iff_exists
code: theorem eq_mk_iff_exists {X : C} {P : Cᵒᵖ ⥤ D} {S T : J.Cover X} (x : Meq P S) (y : Meq P T) :
    mk x = mk y ↔ ∃ (W : J.Cover X) (h1 : W ⟶ S) (h2 : W ⟶ T), x.refine h1 = y.refine h2 
goal: CategoryTheory.GrothendieckTopology.Plus.mk x = CategoryTheory.GrothendieckTopology.Plus.mk y ↔
  ∃ W h1 h2, x.refine h1 = y.refine h2

full_name: CategoryTheory.GrothendieckTopology.Plus.sep
code: /-- `P⁺` is always separated. -/
theorem sep {X : C} (P : Cᵒᵖ ⥤ D) (S : J.Cover X) (x y : (J.plusObj P).obj (op X))
    (h : ∀ I : S.Arrow, (J.plusObj P).map I.f.op x = (J.plusObj P).map I.f.op y) : x = y 
goal: x = y

full_name: CategoryTheory.GrothendieckTopology.Plus.inj_of_sep
code: theorem inj_of_sep (P : Cᵒᵖ ⥤ D)
    (hsep :
      ∀ (X : C) (S : J.Cover X) (x y : P.obj (op X)),
        (∀ I : S.Arrow, P.map I.f.op x = P.map I.f.op y) → x = y)
    (X : C) : Function.Injective ((J.toPlus P).app (op X)) 
goal: Function.Injective ⇑((J.toPlus P).app (Opposite.op X))

full_name: CategoryTheory.GrothendieckTopology.Plus.meqOfSep
code: /-- An auxiliary definition to be used in the proof of `exists_of_sep` below.
  Given a compatible family of local sections for `P⁺`, and representatives of said sections,
  construct a compatible family of local sections of `P` over the combination of the covers
  associated to the representatives.
  The separatedness condition is used to prove compatibility among these local sections of `P`. -/
def meqOfSep (P : Cᵒᵖ ⥤ D)
    (hsep :
      ∀ (X : C) (S : J.Cover X) (x y : P.obj (op X)),
        (∀ I : S.Arrow, P.map I.f.op x = P.map I.f.op y) → x = y)
    (X : C) (S : J.Cover X) (s : Meq (J.plusObj P) S) (T : ∀ I : S.Arrow, J.Cover I.Y)
    (t : ∀ I : S.Arrow, Meq P (T I)) (ht : ∀ I : S.Arrow, s I = mk (t I)) : Meq P (S.bind T) 
goal: CategoryTheory.Meq P (S.bind T)

full_name: CategoryTheory.GrothendieckTopology.Plus.exists_of_sep
code: theorem exists_of_sep (P : Cᵒᵖ ⥤ D)
    (hsep :
      ∀ (X : C) (S : J.Cover X) (x y : P.obj (op X)),
        (∀ I : S.Arrow, P.map I.f.op x = P.map I.f.op y) → x = y)
    (X : C) (S : J.Cover X) (s : Meq (J.plusObj P) S) :
    ∃ t : (J.plusObj P).obj (op X), Meq.mk S t = s 
goal: ∃ t, CategoryTheory.Meq.mk S t = s

full_name: CategoryTheory.GrothendieckTopology.Plus.isSheaf_of_sep
code: /-- If `P` is separated, then `P⁺` is a sheaf. -/
theorem isSheaf_of_sep (P : Cᵒᵖ ⥤ D)
    (hsep :
      ∀ (X : C) (S : J.Cover X) (x y : P.obj (op X)),
        (∀ I : S.Arrow, P.map I.f.op x = P.map I.f.op y) → x = y) :
    Presheaf.IsSheaf J (J.plusObj P) 
goal: CategoryTheory.Presheaf.IsSheaf J (J.plusObj P)

full_name: CategoryTheory.GrothendieckTopology.Plus.isSheaf_plus_plus
code: /-- `P⁺⁺` is always a sheaf. -/
theorem isSheaf_plus_plus (P : Cᵒᵖ ⥤ D) : Presheaf.IsSheaf J (J.plusObj (J.plusObj P)) 
goal: CategoryTheory.Presheaf.IsSheaf J (J.plusObj (J.plusObj P))

full_name: CategoryTheory.GrothendieckTopology.sheafify
code: /-- The sheafification of a presheaf `P`.
*NOTE:* Additional hypotheses are needed to obtain a proof that this is a sheaf! -/
noncomputable def sheafify (P : Cᵒᵖ ⥤ D) : Cᵒᵖ ⥤ D 
goal: CategoryTheory.Functor Cᵒᵖ D

full_name: CategoryTheory.GrothendieckTopology.toSheafify
code: /-- The canonical map from `P` to its sheafification. -/
noncomputable def toSheafify (P : Cᵒᵖ ⥤ D) : P ⟶ J.sheafify P 
goal: P ⟶ J.sheafify P

full_name: CategoryTheory.GrothendieckTopology.sheafifyMap
code: /-- The canonical map on sheafifications induced by a morphism. -/
noncomputable def sheafifyMap {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) : J.sheafify P ⟶ J.sheafify Q 
goal: J.sheafify P ⟶ J.sheafify Q

full_name: CategoryTheory.GrothendieckTopology.sheafifyMap_id
code: @[simp]
theorem sheafifyMap_id (P : Cᵒᵖ ⥤ D) : J.sheafifyMap (𝟙 P) = 𝟙 (J.sheafify P) 
goal: J.sheafifyMap (CategoryTheory.CategoryStruct.id P) = CategoryTheory.CategoryStruct.id (J.sheafify P)

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

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

full_name: CategoryTheory.GrothendieckTopology.sheafification
code: /-- The sheafification of a presheaf `P`, as a functor.
*NOTE:* Additional hypotheses are needed to obtain a proof that this is a sheaf! -/
noncomputable def sheafification : (Cᵒᵖ ⥤ D) ⥤ Cᵒᵖ ⥤ D 
goal: CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ D) (CategoryTheory.Functor Cᵒᵖ D)

full_name: CategoryTheory.GrothendieckTopology.sheafification_obj
code: @[simp]
theorem sheafification_obj (P : Cᵒᵖ ⥤ D) : (J.sheafification D).obj P = J.sheafify P 
goal: (J.sheafification D).obj P = J.sheafify P

full_name: CategoryTheory.GrothendieckTopology.sheafification_map
code: @[simp]
theorem sheafification_map {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) :
    (J.sheafification D).map η = J.sheafifyMap η 
goal: (J.sheafification D).map η = J.sheafifyMap η

full_name: CategoryTheory.GrothendieckTopology.toSheafification
code: /-- The canonical map from `P` to its sheafification, as a natural transformation.
*Note:* We only show this is a sheaf under additional hypotheses on `D`. -/
noncomputable def toSheafification : 𝟭 _ ⟶ sheafification J D 
goal: CategoryTheory.Functor.id (CategoryTheory.Functor Cᵒᵖ D) ⟶ J.sheafification D

full_name: CategoryTheory.GrothendieckTopology.toSheafification_app
code: @[simp]
theorem toSheafification_app (P : Cᵒᵖ ⥤ D) :
    (J.toSheafification D).app P = J.toSheafify P 
goal: (J.toSheafification D).app P = J.toSheafify P

full_name: CategoryTheory.GrothendieckTopology.isIso_toSheafify
code: theorem isIso_toSheafify {P : Cᵒᵖ ⥤ D} (hP : Presheaf.IsSheaf J P) : IsIso (J.toSheafify P) 
goal: CategoryTheory.IsIso (J.toSheafify P)

full_name: CategoryTheory.GrothendieckTopology.isoSheafify
code: /-- If `P` is a sheaf, then `P` is isomorphic to `J.sheafify P`. -/
noncomputable def isoSheafify {P : Cᵒᵖ ⥤ D} (hP : Presheaf.IsSheaf J P) : P ≅ J.sheafify P 
goal: P ≅ J.sheafify P

full_name: CategoryTheory.GrothendieckTopology.isoSheafify_hom
code: @[simp]
theorem isoSheafify_hom {P : Cᵒᵖ ⥤ D} (hP : Presheaf.IsSheaf J P) :
    (J.isoSheafify hP).hom = J.toSheafify P 
goal: (J.isoSheafify hP).hom = J.toSheafify P

full_name: CategoryTheory.GrothendieckTopology.sheafifyLift
code: /-- Given a sheaf `Q` and a morphism `P ⟶ Q`, construct a morphism from `J.sheafify P` to `Q`. -/
noncomputable def sheafifyLift {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) (hQ : Presheaf.IsSheaf J Q) :
    J.sheafify P ⟶ Q 
goal: J.sheafify P ⟶ Q

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

full_name: CategoryTheory.GrothendieckTopology.sheafifyLift_unique
code: theorem sheafifyLift_unique {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) (hQ : Presheaf.IsSheaf J Q)
    (γ : J.sheafify P ⟶ Q) : J.toSheafify P ≫ γ = η → γ = sheafifyLift J η hQ 
goal: CategoryTheory.CategoryStruct.comp (J.toSheafify P) γ = η → γ = J.sheafifyLift η hQ

full_name: CategoryTheory.GrothendieckTopology.isoSheafify_inv
code: @[simp]
theorem isoSheafify_inv {P : Cᵒᵖ ⥤ D} (hP : Presheaf.IsSheaf J P) :
    (J.isoSheafify hP).inv = J.sheafifyLift (𝟙 _) hP 
goal: (J.isoSheafify hP).inv = J.sheafifyLift (CategoryTheory.CategoryStruct.id P) hP

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

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

full_name: CategoryTheory.GrothendieckTopology.sheafify_isSheaf
code: theorem GrothendieckTopology.sheafify_isSheaf (P : Cᵒᵖ ⥤ D) : Presheaf.IsSheaf J (J.sheafify P) 
goal: CategoryTheory.Presheaf.IsSheaf J (J.sheafify P)

full_name: CategoryTheory.plusPlusSheaf_map_val
code: /-- The sheafification functor, as a functor taking values in `Sheaf`. -/
@[simps]
noncomputable def plusPlusSheaf : (Cᵒᵖ ⥤ D) ⥤ Sheaf J D 
goal: ∀ {X Y : CategoryTheory.Functor Cᵒᵖ D} (η : X ⟶ Y), ((CategoryTheory.plusPlusSheaf J D).map η).val = J.sheafifyMap η

full_name: CategoryTheory.plusPlusSheaf
code: /-- The sheafification functor, as a functor taking values in `Sheaf`. -/
@[simps]
noncomputable def plusPlusSheaf : (Cᵒᵖ ⥤ D) ⥤ Sheaf J D 
goal: CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ D) (CategoryTheory.Sheaf J D)

full_name: CategoryTheory.plusPlusSheaf_obj_val
code: /-- The sheafification functor, as a functor taking values in `Sheaf`. -/
@[simps]
noncomputable def plusPlusSheaf : (Cᵒᵖ ⥤ D) ⥤ Sheaf J D 
goal: ((CategoryTheory.plusPlusSheaf J D).obj P).val = J.sheafify P

full_name: CategoryTheory.plusPlusSheaf_preservesZeroMorphisms
code: instance plusPlusSheaf_preservesZeroMorphisms [Preadditive D] :
    (plusPlusSheaf J D).PreservesZeroMorphisms 
goal: (CategoryTheory.plusPlusSheaf J D).PreservesZeroMorphisms

full_name: CategoryTheory.plusPlusAdjunction_unit_app
code: /-- The sheafification functor is left adjoint to the forgetful functor. -/
@[simps! unit_app counit_app_val]
noncomputable def plusPlusAdjunction : plusPlusSheaf J D ⊣ sheafToPresheaf J D 
goal: (CategoryTheory.plusPlusAdjunction J D).unit.app X = J.toSheafify X

full_name: CategoryTheory.plusPlusAdjunction_counit_app_val
code: /-- The sheafification functor is left adjoint to the forgetful functor. -/
@[simps! unit_app counit_app_val]
noncomputable def plusPlusAdjunction : plusPlusSheaf J D ⊣ sheafToPresheaf J D 
goal: ((CategoryTheory.plusPlusAdjunction J D).counit.app Y).val = J.sheafifyLift (CategoryTheory.CategoryStruct.id Y.val) ⋯

full_name: CategoryTheory.plusPlusAdjunction
code: /-- The sheafification functor is left adjoint to the forgetful functor. -/
@[simps! unit_app counit_app_val]
noncomputable def plusPlusAdjunction : plusPlusSheaf J D ⊣ sheafToPresheaf J D 
goal: CategoryTheory.plusPlusSheaf J D ⊣ CategoryTheory.sheafToPresheaf J D

full_name: CategoryTheory.sheafToPresheaf_isRightAdjoint
code: instance sheafToPresheaf_isRightAdjoint : (sheafToPresheaf J D).IsRightAdjoint  
goal: (CategoryTheory.sheafToPresheaf J D).IsRightAdjoint

full_name: CategoryTheory.presheaf_mono_of_mono
code: instance presheaf_mono_of_mono {F G : Sheaf J D} (f : F ⟶ G) [Mono f] : Mono f.1 
goal: CategoryTheory.Mono f.val

full_name: CategoryTheory.Sheaf.Hom.mono_iff_presheaf_mono
code: theorem Sheaf.Hom.mono_iff_presheaf_mono {F G : Sheaf J D} (f : F ⟶ G) : Mono f ↔ Mono f.1 
goal: CategoryTheory.Mono f ↔ CategoryTheory.Mono f.val

full_name: CategoryTheory.GrothendieckTopology.sheafificationIsoPresheafToSheafCompSheafToPreasheaf_inv_app
code: @[simps! hom_app inv_app]
noncomputable
def GrothendieckTopology.sheafificationIsoPresheafToSheafCompSheafToPreasheaf :
    J.sheafification D ≅ plusPlusSheaf J D ⋙ sheafToPresheaf J D 
goal: (J.sheafificationIsoPresheafToSheafCompSheafToPreasheaf D).inv.app X = CategoryTheory.CategoryStruct.id (J.sheafify X)

full_name: CategoryTheory.GrothendieckTopology.sheafificationIsoPresheafToSheafCompSheafToPreasheaf_hom_app
code: @[simps! hom_app inv_app]
noncomputable
def GrothendieckTopology.sheafificationIsoPresheafToSheafCompSheafToPreasheaf :
    J.sheafification D ≅ plusPlusSheaf J D ⋙ sheafToPresheaf J D 
goal: (J.sheafificationIsoPresheafToSheafCompSheafToPreasheaf D).hom.app X = CategoryTheory.CategoryStruct.id (J.sheafify X)

full_name: CategoryTheory.GrothendieckTopology.sheafificationIsoPresheafToSheafCompSheafToPreasheaf
code: @[simps! hom_app inv_app]
noncomputable
def GrothendieckTopology.sheafificationIsoPresheafToSheafCompSheafToPreasheaf :
    J.sheafification D ≅ plusPlusSheaf J D ⋙ sheafToPresheaf J D 
goal: J.sheafification D ≅ (CategoryTheory.plusPlusSheaf J D).comp (CategoryTheory.sheafToPresheaf J D)