l3lab/ntp-mathlib huggingface dataset:
/-- The sheafification functor is left adjoint to the forgetful functor. -/
@[simps! unit_app counit_app_val]
noncomputable def sheafificationAdjunction : presheafToSheaf J D ⊣ sheafToPresheaf J D :=
  Adjunction.mkOfHomEquiv
    { homEquiv := fun P Q =>
        { toFun := fun e => J.toSheafify P ≫ e.val
          invFun := fun e => ⟨J.sheafifyLift e Q.2⟩
          left_inv := fun e => Sheaf.Hom.ext _ _ <| (J.sheafifyLift_unique _ _ _ rfl).symm
          right_inv := fun e => J.toSheafify_sheafifyLift _ _ }
      homEquiv_naturality_left_symm := by
        

Proof state:
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
⊢ ∀ {X' X : Cᵒᵖ ⥤ D} {Y : Sheaf J D} (f : X' ⟶ X) (g : X ⟶ (sheafToPresheaf J D).obj Y),
    ((fun P Q =>
              { toFun := fun e => GrothendieckTopology.toSheafify J P ≫ e.val,
                invFun := fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) },
                left_inv :=
                  (_ :
                    ∀ (e : (presheafToSheaf J D).obj P ⟶ Q),
                      (fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) })
                          ((fun e => GrothendieckTopology.toSheafify J P ≫ e.val) e) =
                        e),
                right_inv :=
                  (_ :
                    ∀ (e : P ⟶ (sheafToPresheaf J D).obj Q),
                      GrothendieckTopology.toSheafify J P ≫
                          GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) =
                        e) })
            X' Y).symm
        (f ≫ g) =
      (presheafToSheaf J D).map f ≫
        ((fun P Q =>
                { toFun := fun e => GrothendieckTopology.toSheafify J P ≫ e.val,
                  invFun := fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) },
                  left_inv :=
                    (_ :
                      ∀ (e : (presheafToSheaf J D).obj P ⟶ Q),
                        (fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) })
                            ((fun e => GrothendieckTopology.toSheafify J P ≫ e.val) e) =
                          e),
                  right_inv :=
                    (_ :
                      ∀ (e : P ⟶ (sheafToPresheaf J D).obj Q),
                        GrothendieckTopology.toSheafify J P ≫
                            GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) =
                          e) })
              X Y).symm
          g

Next tactic:
intro P Q R η γ
/-- The sheafification functor is left adjoint to the forgetful functor. -/
@[simps! unit_app counit_app_val]
noncomputable def sheafificationAdjunction : presheafToSheaf J D ⊣ sheafToPresheaf J D :=
  Adjunction.mkOfHomEquiv
    { homEquiv := fun P Q =>
        { toFun := fun e => J.toSheafify P ≫ e.val
          invFun := fun e => ⟨J.sheafifyLift e Q.2⟩
          left_inv := fun e => Sheaf.Hom.ext _ _ <| (J.sheafifyLift_unique _ _ _ rfl).symm
          right_inv := fun e => J.toSheafify_sheafifyLift _ _ }
      homEquiv_naturality_left_symm := by
        intro P Q R η γ; 

Proof state:
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P Q : Cᵒᵖ ⥤ D
R : Sheaf J D
η : P ⟶ Q
γ : Q ⟶ (sheafToPresheaf J D).obj R
⊢ ((fun P Q =>
            { toFun := fun e => GrothendieckTopology.toSheafify J P ≫ e.val,
              invFun := fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) },
              left_inv :=
                (_ :
                  ∀ (e : (presheafToSheaf J D).obj P ⟶ Q),
                    (fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) })
                        ((fun e => GrothendieckTopology.toSheafify J P ≫ e.val) e) =
                      e),
              right_inv :=
                (_ :
                  ∀ (e : P ⟶ (sheafToPresheaf J D).obj Q),
                    GrothendieckTopology.toSheafify J P ≫
                        GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) =
                      e) })
          P R).symm
      (η ≫ γ) =
    (presheafToSheaf J D).map η ≫
      ((fun P Q =>
              { toFun := fun e => GrothendieckTopology.toSheafify J P ≫ e.val,
                invFun := fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) },
                left_inv :=
                  (_ :
                    ∀ (e : (presheafToSheaf J D).obj P ⟶ Q),
                      (fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) })
                          ((fun e => GrothendieckTopology.toSheafify J P ≫ e.val) e) =
                        e),
                right_inv :=
                  (_ :
                    ∀ (e : P ⟶ (sheafToPresheaf J D).obj Q),
                      GrothendieckTopology.toSheafify J P ≫
                          GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) =
                        e) })
            Q R).symm
        γ

Next tactic:
ext1
/-- The sheafification functor is left adjoint to the forgetful functor. -/
@[simps! unit_app counit_app_val]
noncomputable def sheafificationAdjunction : presheafToSheaf J D ⊣ sheafToPresheaf J D :=
  Adjunction.mkOfHomEquiv
    { homEquiv := fun P Q =>
        { toFun := fun e => J.toSheafify P ≫ e.val
          invFun := fun e => ⟨J.sheafifyLift e Q.2⟩
          left_inv := fun e => Sheaf.Hom.ext _ _ <| (J.sheafifyLift_unique _ _ _ rfl).symm
          right_inv := fun e => J.toSheafify_sheafifyLift _ _ }
      homEquiv_naturality_left_symm := by
        intro P Q R η γ; ext1; 

Proof state:
case h
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P Q : Cᵒᵖ ⥤ D
R : Sheaf J D
η : P ⟶ Q
γ : Q ⟶ (sheafToPresheaf J D).obj R
⊢ (((fun P Q =>
              { toFun := fun e => GrothendieckTopology.toSheafify J P ≫ e.val,
                invFun := fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) },
                left_inv :=
                  (_ :
                    ∀ (e : (presheafToSheaf J D).obj P ⟶ Q),
                      (fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) })
                          ((fun e => GrothendieckTopology.toSheafify J P ≫ e.val) e) =
                        e),
                right_inv :=
                  (_ :
                    ∀ (e : P ⟶ (sheafToPresheaf J D).obj Q),
                      GrothendieckTopology.toSheafify J P ≫
                          GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) =
                        e) })
            P R).symm
        (η ≫ γ)).val =
    ((presheafToSheaf J D).map η ≫
        ((fun P Q =>
                { toFun := fun e => GrothendieckTopology.toSheafify J P ≫ e.val,
                  invFun := fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) },
                  left_inv :=
                    (_ :
                      ∀ (e : (presheafToSheaf J D).obj P ⟶ Q),
                        (fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) })
                            ((fun e => GrothendieckTopology.toSheafify J P ≫ e.val) e) =
                          e),
                  right_inv :=
                    (_ :
                      ∀ (e : P ⟶ (sheafToPresheaf J D).obj Q),
                        GrothendieckTopology.toSheafify J P ≫
                            GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) =
                          e) })
              Q R).symm
          γ).val

Next tactic:
dsimp
/-- The sheafification functor is left adjoint to the forgetful functor. -/
@[simps! unit_app counit_app_val]
noncomputable def sheafificationAdjunction : presheafToSheaf J D ⊣ sheafToPresheaf J D :=
  Adjunction.mkOfHomEquiv
    { homEquiv := fun P Q =>
        { toFun := fun e => J.toSheafify P ≫ e.val
          invFun := fun e => ⟨J.sheafifyLift e Q.2⟩
          left_inv := fun e => Sheaf.Hom.ext _ _ <| (J.sheafifyLift_unique _ _ _ rfl).symm
          right_inv := fun e => J.toSheafify_sheafifyLift _ _ }
      homEquiv_naturality_left_symm := by
        intro P Q R η γ; ext1; dsimp; 

Proof state:
case h
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P Q : Cᵒᵖ ⥤ D
R : Sheaf J D
η : P ⟶ Q
γ : Q ⟶ (sheafToPresheaf J D).obj R
⊢ GrothendieckTopology.sheafifyLift J (η ≫ γ) (_ : Presheaf.IsSheaf J R.val) =
    GrothendieckTopology.sheafifyMap J η ≫ GrothendieckTopology.sheafifyLift J γ (_ : Presheaf.IsSheaf J R.val)

Next tactic:
symm
/-- The sheafification functor is left adjoint to the forgetful functor. -/
@[simps! unit_app counit_app_val]
noncomputable def sheafificationAdjunction : presheafToSheaf J D ⊣ sheafToPresheaf J D :=
  Adjunction.mkOfHomEquiv
    { homEquiv := fun P Q =>
        { toFun := fun e => J.toSheafify P ≫ e.val
          invFun := fun e => ⟨J.sheafifyLift e Q.2⟩
          left_inv := fun e => Sheaf.Hom.ext _ _ <| (J.sheafifyLift_unique _ _ _ rfl).symm
          right_inv := fun e => J.toSheafify_sheafifyLift _ _ }
      homEquiv_naturality_left_symm := by
        intro P Q R η γ; ext1; dsimp; symm
        

Proof state:
case h
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P Q : Cᵒᵖ ⥤ D
R : Sheaf J D
η : P ⟶ Q
γ : Q ⟶ (sheafToPresheaf J D).obj R
⊢ GrothendieckTopology.sheafifyMap J η ≫ GrothendieckTopology.sheafifyLift J γ (_ : Presheaf.IsSheaf J R.val) =
    GrothendieckTopology.sheafifyLift J (η ≫ γ) (_ : Presheaf.IsSheaf J R.val)

Next tactic:
apply J.sheafifyMap_sheafifyLift
/-- The sheafification functor is left adjoint to the forgetful functor. -/
@[simps! unit_app counit_app_val]
noncomputable def sheafificationAdjunction : presheafToSheaf J D ⊣ sheafToPresheaf J D :=
  Adjunction.mkOfHomEquiv
    { homEquiv := fun P Q =>
        { toFun := fun e => J.toSheafify P ≫ e.val
          invFun := fun e => ⟨J.sheafifyLift e Q.2⟩
          left_inv := fun e => Sheaf.Hom.ext _ _ <| (J.sheafifyLift_unique _ _ _ rfl).symm
          right_inv := fun e => J.toSheafify_sheafifyLift _ _ }
      homEquiv_naturality_left_symm := by
        intro P Q R η γ; ext1; dsimp; symm
        apply J.sheafifyMap_sheafifyLift
      homEquiv_naturality_right := fun η γ => by
        

Proof state:
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
X✝ : Cᵒᵖ ⥤ D
Y✝ Y'✝ : Sheaf J D
η : (presheafToSheaf J D).obj X✝ ⟶ Y✝
γ : Y✝ ⟶ Y'✝
⊢ ((fun P Q =>
          { toFun := fun e => GrothendieckTopology.toSheafify J P ≫ e.val,
            invFun := fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) },
            left_inv :=
              (_ :
                ∀ (e : (presheafToSheaf J D).obj P ⟶ Q),
                  (fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) })
                      ((fun e => GrothendieckTopology.toSheafify J P ≫ e.val) e) =
                    e),
            right_inv :=
              (_ :
                ∀ (e : P ⟶ (sheafToPresheaf J D).obj Q),
                  GrothendieckTopology.toSheafify J P ≫
                      GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) =
                    e) })
        X✝ Y'✝)
      (η ≫ γ) =
    ((fun P Q =>
            { toFun := fun e => GrothendieckTopology.toSheafify J P ≫ e.val,
              invFun := fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) },
              left_inv :=
                (_ :
                  ∀ (e : (presheafToSheaf J D).obj P ⟶ Q),
                    (fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) })
                        ((fun e => GrothendieckTopology.toSheafify J P ≫ e.val) e) =
                      e),
              right_inv :=
                (_ :
                  ∀ (e : P ⟶ (sheafToPresheaf J D).obj Q),
                    GrothendieckTopology.toSheafify J P ≫
                        GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) =
                      e) })
          X✝ Y✝)
        η ≫
      (sheafToPresheaf J D).map γ

Next tactic:
dsimp
/-- The sheafification functor is left adjoint to the forgetful functor. -/
@[simps! unit_app counit_app_val]
noncomputable def sheafificationAdjunction : presheafToSheaf J D ⊣ sheafToPresheaf J D :=
  Adjunction.mkOfHomEquiv
    { homEquiv := fun P Q =>
        { toFun := fun e => J.toSheafify P ≫ e.val
          invFun := fun e => ⟨J.sheafifyLift e Q.2⟩
          left_inv := fun e => Sheaf.Hom.ext _ _ <| (J.sheafifyLift_unique _ _ _ rfl).symm
          right_inv := fun e => J.toSheafify_sheafifyLift _ _ }
      homEquiv_naturality_left_symm := by
        intro P Q R η γ; ext1; dsimp; symm
        apply J.sheafifyMap_sheafifyLift
      homEquiv_naturality_right := fun η γ => by
        dsimp
        

Proof state:
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
X✝ : Cᵒᵖ ⥤ D
Y✝ Y'✝ : Sheaf J D
η : (presheafToSheaf J D).obj X✝ ⟶ Y✝
γ : Y✝ ⟶ Y'✝
⊢ GrothendieckTopology.toSheafify J X✝ ≫ η.val ≫ γ.val = (GrothendieckTopology.toSheafify J X✝ ≫ η.val) ≫ γ.val

Next tactic:
rw [Category.assoc]
theorem Sheaf.Hom.mono_iff_presheaf_mono {F G : Sheaf J D} (f : F ⟶ G) : Mono f ↔ Mono f.1 :=
  ⟨fun m => by 

Proof state:
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
F G : Sheaf J D
f : F ⟶ G
m : Mono f
⊢ Mono f.val

Next tactic:
infer_instance
theorem Sheaf.Hom.mono_iff_presheaf_mono {F G : Sheaf J D} (f : F ⟶ G) : Mono f ↔ Mono f.1 :=
  ⟨fun m => by infer_instance, fun m => by 

Proof state:
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
F G : Sheaf J D
f : F ⟶ G
m : Mono f.val
⊢ Mono f

Next tactic:
exact Sheaf.Hom.mono_of_presheaf_mono J D f
/-- A sheaf `P` is isomorphic to its own sheafification. -/
@[simps]
noncomputable def sheafificationIso (P : Sheaf J D) : P ≅ (presheafToSheaf J D).obj P.val where
  hom := ⟨(J.isoSheafify P.2).hom⟩
  inv := ⟨(J.isoSheafify P.2).inv⟩
  hom_inv_id := by
    

Proof state:
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Sheaf J D
⊢ { val := (GrothendieckTopology.isoSheafify J (_ : Presheaf.IsSheaf J P.val)).hom } ≫
      { val := (GrothendieckTopology.isoSheafify J (_ : Presheaf.IsSheaf J P.val)).inv } =
    𝟙 P

Next tactic:
ext1
/-- A sheaf `P` is isomorphic to its own sheafification. -/
@[simps]
noncomputable def sheafificationIso (P : Sheaf J D) : P ≅ (presheafToSheaf J D).obj P.val where
  hom := ⟨(J.isoSheafify P.2).hom⟩
  inv := ⟨(J.isoSheafify P.2).inv⟩
  hom_inv_id := by
    ext1
    

Proof state:
case h
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Sheaf J D
⊢ ({ val := (GrothendieckTopology.isoSheafify J (_ : Presheaf.IsSheaf J P.val)).hom } ≫
        { val := (GrothendieckTopology.isoSheafify J (_ : Presheaf.IsSheaf J P.val)).inv }).val =
    (𝟙 P).val

Next tactic:
apply (J.isoSheafify P.2).hom_inv_id
/-- A sheaf `P` is isomorphic to its own sheafification. -/
@[simps]
noncomputable def sheafificationIso (P : Sheaf J D) : P ≅ (presheafToSheaf J D).obj P.val where
  hom := ⟨(J.isoSheafify P.2).hom⟩
  inv := ⟨(J.isoSheafify P.2).inv⟩
  hom_inv_id := by
    ext1
    apply (J.isoSheafify P.2).hom_inv_id
  inv_hom_id := by
    

Proof state:
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Sheaf J D
⊢ { val := (GrothendieckTopology.isoSheafify J (_ : Presheaf.IsSheaf J P.val)).inv } ≫
      { val := (GrothendieckTopology.isoSheafify J (_ : Presheaf.IsSheaf J P.val)).hom } =
    𝟙 ((presheafToSheaf J D).obj P.val)

Next tactic:
ext1
/-- A sheaf `P` is isomorphic to its own sheafification. -/
@[simps]
noncomputable def sheafificationIso (P : Sheaf J D) : P ≅ (presheafToSheaf J D).obj P.val where
  hom := ⟨(J.isoSheafify P.2).hom⟩
  inv := ⟨(J.isoSheafify P.2).inv⟩
  hom_inv_id := by
    ext1
    apply (J.isoSheafify P.2).hom_inv_id
  inv_hom_id := by
    ext1
    

Proof state:
case h
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Sheaf J D
⊢ ({ val := (GrothendieckTopology.isoSheafify J (_ : Presheaf.IsSheaf J P.val)).inv } ≫
        { val := (GrothendieckTopology.isoSheafify J (_ : Presheaf.IsSheaf J P.val)).hom }).val =
    (𝟙 ((presheafToSheaf J D).obj P.val)).val

Next tactic:
apply (J.isoSheafify P.2).inv_hom_id
/-- The induced scalar multiplication on
`colimit (F ⋙ forget₂ _ AddCommGroupCat)`. -/
@[simps]
noncomputable def coconePointSMul :
    R →+* End (colimit (F ⋙ forget₂ _ AddCommGroupCat)) where
  toFun r := colimMap
    { app := fun j => (F.obj j).smul r
      naturality := fun X Y f => smul_naturality _ _ }
  map_zero' := colimit.hom_ext (by simp)
  map_one' := colimit.hom_ext (by 

Proof state:
R : Type w
inst✝² : Ring R
J : Type u
inst✝¹ : Category.{v, u} J
F : J ⥤ ModuleCat R
inst✝ : HasColimit (F ⋙ forget₂ (ModuleCat R) AddCommGroupCat)
⊢ ∀ (j : J),
    colimit.ι (F ⋙ forget₂ (ModuleCat R) AddCommGroupCat) j ≫
        (fun r => colimMap (NatTrans.mk fun j => (smul (F.obj j)) r)) 1 =
      colimit.ι (F ⋙ forget₂ (ModuleCat R) AddCommGroupCat) j ≫ 1

Next tactic:
simp