awhecmu/canonical-drafter-extract-mathlib huggingface dataset:
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafification (goal)
Goal:
C : Type u'
inst : Category.{v', u'} C
J : GrothendieckTopology.{v', u'} C
R₀ : CategoryTheory.Functor.{v', u, u', u + 1} Cᵒᵖ RingCat
R : Sheaf J RingCat
α : R₀ ⟶ R.obj (P := Presheaf.IsSheaf J)
inst_1 :
  Presheaf.IsLocallyInjective (FD := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CD := RingCat.carrier)
    J α
inst_2 :
  Presheaf.IsLocallySurjective J (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA :=
    RingCat.carrier) α
inst_3 :
  J.WEqualsLocallyBijective AddCommGrpCat (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v))
    (CA := AddCommGrpCat.carrier)
inst_4 : HasWeakSheafify J AddCommGrpCat
P₀ : PresheafOfModules.{v, v', u', u} R₀
M N : SheafOfModules.{v, v', u', u} R
f : (sheafification α).obj P₀ ⟶ M
g : M ⟶ N
⊢ Eq (α := P₀ ⟶ (SheafOfModules.forget R ⋙ restrictScalars α).obj N)
    ((sheafificationHomEquiv α :
          (a : (sheafification α).obj P₀ ⟶ N) → P₀ ⟶ (SheafOfModules.forget R ⋙ restrictScalars α).obj N)
        (f ≫ g) :
      P₀ ⟶ (SheafOfModules.forget R ⋙ restrictScalars α).obj N)
    ((sheafificationHomEquiv α :
            (a : (sheafification α).obj P₀ ⟶ M) → P₀ ⟶ (SheafOfModules.forget R ⋙ restrictScalars α).obj M)
          f ≫
        (SheafOfModules.forget R ⋙ restrictScalars α).map g :
      P₀ ⟶ (SheafOfModules.forget R ⋙ restrictScalars α).obj N)
have a : Eq (α := (toPresheaf R₀).obj P₀ ⟶ (toPresheaf R₀).obj ((SheafOfModules.forget R ⋙ restrictScalars α).obj N))
  ((toPresheaf R₀).map
    ((sheafificationHomEquiv α :
        (a : (sheafification α).obj P₀ ⟶ N) → P₀ ⟶ (SheafOfModules.forget R ⋙ restrictScalars α).obj N)
      (f ≫ g)))
  ((toPresheaf R₀).map
    ((sheafificationHomEquiv α :
          (a : (sheafification α).obj P₀ ⟶ M) → P₀ ⟶ (SheafOfModules.forget R ⋙ restrictScalars α).obj M)
        f ≫
      (SheafOfModules.forget R ⋙ restrictScalars α).map g))
Tactic: apply (toPresheaf _).map_injective
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafification (goal)
Goal:
C : Type u'
inst : Category.{v', u'} C
J : GrothendieckTopology.{v', u'} C
R₀ : CategoryTheory.Functor.{v', u, u', u + 1} Cᵒᵖ RingCat
R : Sheaf J RingCat
α : R₀ ⟶ R.obj (P := Presheaf.IsSheaf J)
inst_1 :
  Presheaf.IsLocallyInjective (FD := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CD := RingCat.carrier)
    J α
inst_2 :
  Presheaf.IsLocallySurjective J (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA :=
    RingCat.carrier) α
inst_3 :
  J.WEqualsLocallyBijective AddCommGrpCat (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v))
    (CA := AddCommGrpCat.carrier)
inst_4 : HasWeakSheafify J AddCommGrpCat
P₀ : PresheafOfModules.{v, v', u', u} R₀
M N : SheafOfModules.{v, v', u', u} R
f : (sheafification α).obj P₀ ⟶ M
g : M ⟶ N
⊢ Eq (α := (toPresheaf R₀).obj P₀ ⟶ (toPresheaf R₀).obj ((SheafOfModules.forget R ⋙ restrictScalars α).obj N))
    ((toPresheaf R₀).map
      ((sheafificationHomEquiv α :
          (a : (sheafification α).obj P₀ ⟶ N) → P₀ ⟶ (SheafOfModules.forget R ⋙ restrictScalars α).obj N)
        (f ≫ g)))
    ((toPresheaf R₀).map
      ((sheafificationHomEquiv α :
            (a : (sheafification α).obj P₀ ⟶ M) → P₀ ⟶ (SheafOfModules.forget R ⋙ restrictScalars α).obj M)
          f ≫
        (SheafOfModules.forget R ⋙ restrictScalars α).map g))
have a : Eq (α := (toPresheaf R₀).obj P₀ ⟶ (toPresheaf R₀).obj ((SheafOfModules.forget R ⋙ restrictScalars α).obj N))
  ((Adjunction.homEquiv (CategoryTheory.sheafificationAdjunction J AddCommGrpCat) P₀.presheaf
          ((SheafOfModules.toSheaf R).obj N) :
        (a : (presheafToSheaf J AddCommGrpCat).obj P₀.presheaf ⟶ (SheafOfModules.toSheaf R).obj N) →
          P₀.presheaf ⟶ (sheafToPresheaf J AddCommGrpCat).obj ((SheafOfModules.toSheaf R).obj N))
      ((SheafOfModules.toSheaf R).map (f ≫ g)) :
    P₀.presheaf ⟶ Functor.obj (sheafToPresheaf J AddCommGrpCat) ((SheafOfModules.toSheaf R).obj N))
  ((Adjunction.homEquiv (CategoryTheory.sheafificationAdjunction J AddCommGrpCat) P₀.presheaf
          ((SheafOfModules.toSheaf R).obj N) :
        (a : (presheafToSheaf J AddCommGrpCat).obj P₀.presheaf ⟶ (SheafOfModules.toSheaf R).obj N) →
          P₀.presheaf ⟶ (sheafToPresheaf J AddCommGrpCat).obj ((SheafOfModules.toSheaf R).obj N))
      ((SheafOfModules.toSheaf R).map (f ≫ g)) :
    P₀.presheaf ⟶ Functor.obj (sheafToPresheaf J AddCommGrpCat) ((SheafOfModules.toSheaf R).obj N))
Tactic: erw [toPresheaf_map_sheafificationHomEquiv]
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafification (goal)
Goal:
C : Type u'
inst : Category.{v', u'} C
J : GrothendieckTopology.{v', u'} C
R₀ : CategoryTheory.Functor.{v', u, u', u + 1} Cᵒᵖ RingCat
R : Sheaf J RingCat
α : R₀ ⟶ R.obj (P := Presheaf.IsSheaf J)
inst_1 :
  Presheaf.IsLocallyInjective (FD := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CD := RingCat.carrier)
    J α
inst_2 :
  Presheaf.IsLocallySurjective J (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA :=
    RingCat.carrier) α
inst_3 :
  J.WEqualsLocallyBijective AddCommGrpCat (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v))
    (CA := AddCommGrpCat.carrier)
inst_4 : HasWeakSheafify J AddCommGrpCat
⊢ IsIso (X := (SheafOfModules.forget R ⋙ restrictScalars α) ⋙ sheafification α)
    (Adjunction.counit (sheafificationAdjunction α))
have rw : ∀ (X : SheafOfModules.{v, v', u', u} R),
  IsIso (X := ((SheafOfModules.forget R ⋙ restrictScalars α) ⋙ sheafification α).obj X)
    (NatTrans.app (Adjunction.counit (sheafificationAdjunction α)) X)
Tactic: rw [NatTrans.isIso_iff_isIso_app]
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafification (goal)
Goal:
C : Type u'
inst : Category.{v', u'} C
J : GrothendieckTopology.{v', u'} C
R₀ : CategoryTheory.Functor.{v', u, u', u + 1} Cᵒᵖ RingCat
R : Sheaf J RingCat
α : R₀ ⟶ R.obj (P := Presheaf.IsSheaf J)
inst_1 :
  Presheaf.IsLocallyInjective (FD := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CD := RingCat.carrier)
    J α
inst_2 :
  Presheaf.IsLocallySurjective J (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA :=
    RingCat.carrier) α
inst_3 :
  J.WEqualsLocallyBijective AddCommGrpCat (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v))
    (CA := AddCommGrpCat.carrier)
inst_4 : HasWeakSheafify J AddCommGrpCat
F : SheafOfModules.{v, v', u', u} R
⊢ IsIso (X := ((SheafOfModules.forget R ⋙ restrictScalars α) ⋙ sheafification α).obj F)
    (NatTrans.app (Adjunction.counit (sheafificationAdjunction α)) F)
have rw : IsIso (X := (SheafOfModules.toSheaf R).obj (((SheafOfModules.forget R ⋙ restrictScalars α) ⋙ sheafification α).obj F))
  ((SheafOfModules.toSheaf R).map (NatTrans.app (Adjunction.counit (sheafificationAdjunction α)) F))
Tactic: rw [← isIso_iff_of_reflects_iso _ (SheafOfModules.toSheaf.{v} R)]
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafification (goal)
Goal:
C : Type u'
inst : Category.{v', u'} C
J : GrothendieckTopology.{v', u'} C
R₀ : CategoryTheory.Functor.{v', u, u', u + 1} Cᵒᵖ RingCat
R : Sheaf J RingCat
α : R₀ ⟶ R.obj (P := Presheaf.IsSheaf J)
inst_1 :
  Presheaf.IsLocallyInjective (FD := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CD := RingCat.carrier)
    J α
inst_2 :
  Presheaf.IsLocallySurjective J (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA :=
    RingCat.carrier) α
inst_3 :
  J.WEqualsLocallyBijective AddCommGrpCat (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v))
    (CA := AddCommGrpCat.carrier)
inst_4 : HasWeakSheafify J AddCommGrpCat
F : SheafOfModules.{v, v', u', u} R
⊢ IsIso (X := (SheafOfModules.toSheaf R).obj (((SheafOfModules.forget R ⋙ restrictScalars α) ⋙ sheafification α).obj F))
    ((SheafOfModules.toSheaf R).map (NatTrans.app (Adjunction.counit (sheafificationAdjunction α)) F))
have simp : IsIso (X := (SheafOfModules.toSheaf R).obj ((sheafification α).obj (F.val.restrictScalarsObj α)))
  (NatTrans.app (Adjunction.counit (CategoryTheory.sheafificationAdjunction J AddCommGrpCat))
    ((SheafOfModules.toSheaf R).obj F))
Tactic: simp only [Functor.comp_obj, SheafOfModules.forget_obj, restrictScalars_obj, Functor.id_obj,
    toSheaf_map_sheafificationAdjunction_counit_app]
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify (goal)
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
J : GrothendieckTopology.{v₁, u₁} C
R₀ R : Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
α : R₀ ⟶ R
inst_1 :
  Presheaf.IsLocallyInjective (FD := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CD := RingCat.carrier)
    J α
M₀ : PresheafOfModules.{v, v₁, u₁, u} R₀
A : Functor.{v₁, v, u₁, v + 1} Cᵒᵖ AddCommGrpCat
φ : M₀.presheaf ⟶ A
inst_2 :
  Presheaf.IsLocallyInjective (FD := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CD :=
    AddCommGrpCat.carrier) J φ
hA :
  Presheaf.IsSeparated J A (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
    AddCommGrpCat.carrier)
Y : C
r₀ r₀' : (↑(R₀.obj (Opposite.op Y)) : Type u)
m₀ m₀' : (↑(M₀.obj (Opposite.op Y)) : Type v)
hr₀ :
  Eq (α := (↑(R.obj (Opposite.op Y)) : Type u))
    ((ConcreteCategory.hom (FC := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC := RingCat.carrier)
            (X := R₀.obj (Opposite.op Y)) (α.app (Opposite.op Y)) :
          (a : (↑(R₀.obj (Opposite.op Y)) : Type u)) → (↑(R.obj (Opposite.op Y)) : Type u))
        r₀ :
      (↑(R.obj (Opposite.op Y)) : Type u))
    ((ConcreteCategory.hom (FC := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC := RingCat.carrier)
            (X := R₀.obj (Opposite.op Y)) (α.app (Opposite.op Y)) :
          (a : (↑(R₀.obj (Opposite.op Y)) : Type u)) → (↑(R.obj (Opposite.op Y)) : Type u))
        r₀' :
      (↑(R.obj (Opposite.op Y)) : Type u))
hm₀ :
  Eq (α := (↑(A.obj (Opposite.op Y)) : Type v))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CC :=
            AddCommGrpCat.carrier) (X := M₀.presheaf.obj (Opposite.op Y)) (φ.app (Opposite.op Y)) :
          (a : (↑(M₀.presheaf.obj (Opposite.op Y)) : Type v)) → (↑(A.obj (Opposite.op Y)) : Type v))
        m₀ :
      (↑(A.obj (Opposite.op Y)) : Type v))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CC :=
            AddCommGrpCat.carrier) (X := M₀.presheaf.obj (Opposite.op Y)) (φ.app (Opposite.op Y)) :
          (a : (↑(M₀.presheaf.obj (Opposite.op Y)) : Type v)) → (↑(A.obj (Opposite.op Y)) : Type v))
        m₀' :
      (↑(A.obj (Opposite.op Y)) : Type v))
⊢ Membership.mem (γ := Set (Sieve.{v₁, u₁} (Opposite.unop (Opposite.op Y))))
    ((J : (a : C) → Set (Sieve a)) (Opposite.unop (Opposite.op Y)))
    (Presheaf.equalizerSieve (FD := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CD := RingCat.carrier)
        r₀ r₀' ⊓
      Presheaf.equalizerSieve (FD := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CD :=
        AddCommGrpCat.carrier) (F := M₀.presheaf) m₀ m₀')
have x : Membership.mem (γ := Set (Sieve.{v₁, u₁} (Opposite.unop (Opposite.op Y))))
  ((J : (a : C) → Set (Sieve a)) (Opposite.unop (Opposite.op Y)))
  (Presheaf.equalizerSieve (FD := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CD := RingCat.carrier) r₀
    r₀')
Tactic: apply J.intersection_covering
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify (goal)
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
J : GrothendieckTopology.{v₁, u₁} C
R₀ : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
R : Sheaf J RingCat
α : R₀ ⟶ R.obj (P := Presheaf.IsSheaf J)
inst_1 :
  Presheaf.IsLocallyInjective (FD := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CD := RingCat.carrier)
    J α
inst_2 :
  Presheaf.IsLocallySurjective J (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA :=
    RingCat.carrier) α
M₀ : PresheafOfModules.{v, v₁, u₁, u} R₀
A : Sheaf J AddCommGrpCat
φ : M₀.presheaf ⟶ A.obj (P := Presheaf.IsSheaf J)
inst_3 :
  Presheaf.IsLocallyInjective (FD := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CD :=
    AddCommGrpCat.carrier) J φ
inst_4 :
  Presheaf.IsLocallySurjective J (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
    AddCommGrpCat.carrier) φ
X Y : Cᵒᵖ
π : X ⟶ Y
r r' : (↑(R.obj (P := Presheaf.IsSheaf J).obj X) : Type u)
m m' : (↑(A.obj (P := Presheaf.IsSheaf J).obj X) : Type v)
S : Sieve.{v₁, u₁} (Opposite.unop X) :=
  Presheaf.imageSieve (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA := RingCat.carrier) α r ⊓
    Presheaf.imageSieve (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
      AddCommGrpCat.carrier) φ m
⊢ Membership.mem (γ := Set (Sieve.{v₁, u₁} (Opposite.unop X))) ((J : (a : C) → Set (Sieve a)) (Opposite.unop X)) S
have rj : Membership.mem (γ := Set (Sieve.{v₁, u₁} (Opposite.unop X))) ((J : (a : C) → Set (Sieve a)) (Opposite.unop X))
  (Presheaf.imageSieve (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA := RingCat.carrier) α r)
Tactic: apply J.intersection_covering
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify (goal)
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
J : GrothendieckTopology.{v₁, u₁} C
R₀ : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
R : Sheaf J RingCat
α : R₀ ⟶ R.obj (P := Presheaf.IsSheaf J)
inst_1 :
  Presheaf.IsLocallyInjective (FD := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CD := RingCat.carrier)
    J α
inst_2 :
  Presheaf.IsLocallySurjective J (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA :=
    RingCat.carrier) α
M₀ : PresheafOfModules.{v, v₁, u₁, u} R₀
A : Sheaf J AddCommGrpCat
φ : M₀.presheaf ⟶ A.obj (P := Presheaf.IsSheaf J)
inst_3 :
  Presheaf.IsLocallyInjective (FD := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CD :=
    AddCommGrpCat.carrier) J φ
inst_4 :
  Presheaf.IsLocallySurjective J (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
    AddCommGrpCat.carrier) φ
X Y : Cᵒᵖ
π : X ⟶ Y
r r' : (↑(R.obj (P := Presheaf.IsSheaf J).obj X) : Type u)
m m' : (↑(A.obj (P := Presheaf.IsSheaf J).obj X) : Type v)
S : Sieve.{v₁, u₁} (Opposite.unop X) :=
  Presheaf.imageSieve (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA := RingCat.carrier) α r ⊓
    Presheaf.imageSieve (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
      AddCommGrpCat.carrier) φ m
rj :
  Membership.mem (γ := Set (Sieve.{v₁, u₁} (Opposite.unop X))) ((J : (a : C) → Set (Sieve a)) (Opposite.unop X))
    (Presheaf.imageSieve (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA := RingCat.carrier) α r)
⊢ Membership.mem (γ := Set (Sieve.{v₁, u₁} (Opposite.unop X))) ((J : (a : C) → Set (Sieve a)) (Opposite.unop X)) S
have sj : Membership.mem (γ := Set (Sieve.{v₁, u₁} (Opposite.unop X))) ((J : (a : C) → Set (Sieve a)) (Opposite.unop X))
  (Presheaf.imageSieve (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
    AddCommGrpCat.carrier) φ m)
Tactic: apply J.intersection_covering
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify (hypothesis)
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
J : GrothendieckTopology.{v₁, u₁} C
R₀ : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
R : Sheaf J RingCat
α : R₀ ⟶ R.obj (P := Presheaf.IsSheaf J)
inst_1 :
  Presheaf.IsLocallyInjective (FD := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CD := RingCat.carrier)
    J α
inst_2 :
  Presheaf.IsLocallySurjective J (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA :=
    RingCat.carrier) α
M₀ : PresheafOfModules.{v, v₁, u₁, u} R₀
A : Sheaf J AddCommGrpCat
φ : M₀.presheaf ⟶ A.obj (P := Presheaf.IsSheaf J)
inst_3 :
  Presheaf.IsLocallyInjective (FD := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CD :=
    AddCommGrpCat.carrier) J φ
inst_4 :
  Presheaf.IsLocallySurjective J (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
    AddCommGrpCat.carrier) φ
X Y : Cᵒᵖ
π : X ⟶ Y
r r' : (↑(R.obj (P := Presheaf.IsSheaf J).obj X) : Type u)
m m' : (↑(A.obj (P := Presheaf.IsSheaf J).obj X) : Type v)
S : Sieve.{v₁, u₁} (Opposite.unop X) :=
  Presheaf.imageSieve (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA := RingCat.carrier) α r ⊓
    Presheaf.imageSieve (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
      AddCommGrpCat.carrier) φ m
⊢ SMulCandidate α φ r m
have hS : Membership.mem (γ := Set (Sieve.{v₁, u₁} (Opposite.unop X))) ((J : (a : C) → Set (Sieve a)) (Opposite.unop X)) S
Tactic: have hS : S ∈ J _ := by
    apply J.intersection_covering
    all_goals apply Presheaf.imageSieve_mem
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify (hypothesis)
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
J : GrothendieckTopology.{v₁, u₁} C
R₀ : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
R : Sheaf J RingCat
α : R₀ ⟶ R.obj (P := Presheaf.IsSheaf J)
inst_1 :
  Presheaf.IsLocallyInjective (FD := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CD := RingCat.carrier)
    J α
inst_2 :
  Presheaf.IsLocallySurjective J (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA :=
    RingCat.carrier) α
M₀ : PresheafOfModules.{v, v₁, u₁, u} R₀
A : Sheaf J AddCommGrpCat
φ : M₀.presheaf ⟶ A.obj (P := Presheaf.IsSheaf J)
inst_3 :
  Presheaf.IsLocallyInjective (FD := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CD :=
    AddCommGrpCat.carrier) J φ
inst_4 :
  Presheaf.IsLocallySurjective J (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
    AddCommGrpCat.carrier) φ
X Y : Cᵒᵖ
π : X ⟶ Y
r r' : (↑(R.obj (P := Presheaf.IsSheaf J).obj X) : Type u)
m m' : (↑(A.obj (P := Presheaf.IsSheaf J).obj X) : Type v)
S : Sieve.{v₁, u₁} (Opposite.unop X) :=
  Presheaf.imageSieve (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA := RingCat.carrier) α r ⊓
    Presheaf.imageSieve (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
      AddCommGrpCat.carrier) φ m
hS : Membership.mem (γ := Set (Sieve.{v₁, u₁} (Opposite.unop X))) ((J : (a : C) → Set (Sieve a)) (Opposite.unop X)) S
⊢ SMulCandidate α φ r m
have h₁ : S ≤ Presheaf.imageSieve (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA := RingCat.carrier) α r
Tactic: have h₁ : S ≤ Presheaf.imageSieve α r := fun _ _ h => h.1
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify (hypothesis)
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
J : GrothendieckTopology.{v₁, u₁} C
R₀ : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
R : Sheaf J RingCat
α : R₀ ⟶ R.obj (P := Presheaf.IsSheaf J)
inst_1 :
  Presheaf.IsLocallyInjective (FD := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CD := RingCat.carrier)
    J α
inst_2 :
  Presheaf.IsLocallySurjective J (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA :=
    RingCat.carrier) α
M₀ : PresheafOfModules.{v, v₁, u₁, u} R₀
A : Sheaf J AddCommGrpCat
φ : M₀.presheaf ⟶ A.obj (P := Presheaf.IsSheaf J)
inst_3 :
  Presheaf.IsLocallyInjective (FD := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CD :=
    AddCommGrpCat.carrier) J φ
inst_4 :
  Presheaf.IsLocallySurjective J (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
    AddCommGrpCat.carrier) φ
X Y : Cᵒᵖ
π : X ⟶ Y
r r' : (↑(R.obj (P := Presheaf.IsSheaf J).obj X) : Type u)
m m' : (↑(A.obj (P := Presheaf.IsSheaf J).obj X) : Type v)
S : Sieve.{v₁, u₁} (Opposite.unop X) :=
  Presheaf.imageSieve (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA := RingCat.carrier) α r ⊓
    Presheaf.imageSieve (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
      AddCommGrpCat.carrier) φ m
hS : Membership.mem (γ := Set (Sieve.{v₁, u₁} (Opposite.unop X))) ((J : (a : C) → Set (Sieve a)) (Opposite.unop X)) S
h₁ :
  S ≤ Presheaf.imageSieve (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA := RingCat.carrier) α r
⊢ SMulCandidate α φ r m
have h₂ : S ≤
  Presheaf.imageSieve (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
    AddCommGrpCat.carrier) φ m
Tactic: have h₂ : S ≤ Presheaf.imageSieve φ m := fun _ _ h => h.2
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify (goal)
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
J : GrothendieckTopology.{v₁, u₁} C
R₀ : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
R : Sheaf J RingCat
α : R₀ ⟶ R.obj (P := Presheaf.IsSheaf J)
inst_1 :
  Presheaf.IsLocallyInjective (FD := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CD := RingCat.carrier)
    J α
inst_2 :
  Presheaf.IsLocallySurjective J (FA := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CA :=
    RingCat.carrier) α
M₀ : PresheafOfModules.{v, v₁, u₁, u} R₀
A : Sheaf J AddCommGrpCat
φ : M₀.presheaf ⟶ A.obj (P := Presheaf.IsSheaf J)
inst_3 :
  Presheaf.IsLocallyInjective (FD := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CD :=
    AddCommGrpCat.carrier) J φ
inst_4 :
  Presheaf.IsLocallySurjective J (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
    AddCommGrpCat.carrier) φ
X : Cᵒᵖ
m : (↑(A.obj (P := Presheaf.IsSheaf J).obj X) : Type v)
⊢ smul α φ 1 m = m
have a : ∀ (Y : C) (f : Y ⟶ Opposite.unop X),
  (Presheaf.imageSieve (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
          AddCommGrpCat.carrier) φ m).arrows
      f →
    Eq (α := (↑(A.obj (P := Presheaf.IsSheaf J).obj (Opposite.op Y)) : Type v))
      ((ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CC :=
              AddCommGrpCat.carrier) (A.obj (P := Presheaf.IsSheaf J).map f.op) :
            (a : (↑(A.obj.obj (Opposite.op (Opposite.unop X))) : Type v)) → (↑(A.obj.obj (Opposite.op Y)) : Type v))
          (smul α φ 1 m) :
        (↑(A.obj (P := Presheaf.IsSheaf J).obj (Opposite.op Y)) : Type v))
      ((ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CC :=
              AddCommGrpCat.carrier) (A.obj (P := Presheaf.IsSheaf J).map f.op) :
            (a : (↑(A.obj.obj (Opposite.op (Opposite.unop X))) : Type v)) → (↑(A.obj.obj (Opposite.op Y)) : Type v))
          m :
        (↑(A.obj (P := Presheaf.IsSheaf J).obj (Opposite.op Y)) : Type v))
Tactic: apply A.isSeparated _ _ (Presheaf.imageSieve_mem J φ m)