awhecmu/canonical-drafter-extract-mathlib huggingface dataset:
-- Module: Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify
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) φ
inst_5 :
  J.WEqualsLocallyBijective AddCommGrpCat (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v))
    (CA := AddCommGrpCat.carrier)
M₀' : PresheafOfModules.{v, v₁, u₁, u} R₀
A' : Sheaf J AddCommGrpCat
φ' : M₀'.presheaf ⟶ A'.obj (P := Presheaf.IsSheaf J)
inst_6 :
  Presheaf.IsLocallyInjective (FD := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CD :=
    AddCommGrpCat.carrier) J φ'
inst_7 :
  Presheaf.IsLocallySurjective J (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
    AddCommGrpCat.carrier) φ'
τ₀ : M₀ ⟶ M₀'
τ : A ⟶ A'
fac : (toPresheaf R₀).map τ₀ ≫ φ' = φ ≫ τ.hom
X : Cᵒᵖ
r : (↑(R.obj (P := Presheaf.IsSheaf J).obj X) : Type u)
m : (↑((sheafify α φ).val.obj X) : Type v)
f : (sheafify α φ).val ⟶ (sheafify α φ').val :=
  (Equiv.symm (sheafifyHomEquiv' α φ ⋯) :
      (a : M₀ ⟶ (restrictScalars α).obj (sheafify α φ').val) → (sheafify α φ).val ⟶ (sheafify α φ').val)
    (τ₀ ≫ toSheafify α φ')
a :
  φ ≫ τ.hom =
    φ ≫
      (toPresheaf (R.obj (P := Presheaf.IsSheaf J))).map
        ((Equiv.symm (sheafifyHomEquiv' α φ ⋯) :
            (a : M₀ ⟶ (sheafify α φ').val.restrictScalarsObj α) → (sheafify α φ).val ⟶ (sheafify α φ').val)
          (τ₀ ≫ toSheafify α φ'))
⊢ Eq (α := M₀.presheaf ⟶ A'.obj (P := Presheaf.IsSheaf J))
    ((ObjectProperty.isLocal.homEquiv (P := Presheaf.IsSheaf J) ⋯ (A'.obj (P := Presheaf.IsSheaf J)) ⋯ :
          (a : A.obj ⟶ A'.obj) → M₀.presheaf ⟶ A'.obj)
        τ.hom :
      M₀.presheaf ⟶ A'.obj (P := Presheaf.IsSheaf J))
    ((ObjectProperty.isLocal.homEquiv (P := Presheaf.IsSheaf J) ⋯ (A'.obj (P := Presheaf.IsSheaf J)) ⋯ :
          (a : A.obj ⟶ A'.obj) → M₀.presheaf ⟶ A'.obj)
        ((toPresheaf (R.obj (P := Presheaf.IsSheaf J))).map f) :
      M₀.presheaf ⟶ A'.obj (P := Presheaf.IsSheaf J))

Tactic:
dsimp [f]
-- Module: Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify
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) φ
inst_5 :
  J.WEqualsLocallyBijective AddCommGrpCat (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v))
    (CA := AddCommGrpCat.carrier)
M₀' : PresheafOfModules.{v, v₁, u₁, u} R₀
A' : Sheaf J AddCommGrpCat
φ' : M₀'.presheaf ⟶ A'.obj (P := Presheaf.IsSheaf J)
inst_6 :
  Presheaf.IsLocallyInjective (FD := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CD :=
    AddCommGrpCat.carrier) J φ'
inst_7 :
  Presheaf.IsLocallySurjective J (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
    AddCommGrpCat.carrier) φ'
τ₀ : M₀ ⟶ M₀'
τ : A ⟶ A'
fac : (toPresheaf R₀).map τ₀ ≫ φ' = φ ≫ τ.hom
X : Cᵒᵖ
r : (↑(R.obj (P := Presheaf.IsSheaf J).obj X) : Type u)
m : (↑((sheafify α φ).val.obj X) : Type v)
f : (sheafify α φ).val ⟶ (sheafify α φ').val :=
  (Equiv.symm (sheafifyHomEquiv' α φ ⋯) :
      (a : M₀ ⟶ (restrictScalars α).obj (sheafify α φ').val) → (sheafify α φ).val ⟶ (sheafify α φ').val)
    (τ₀ ≫ toSheafify α φ')
a : φ ≫ τ.hom = (toPresheaf R₀).map (τ₀ ≫ toSheafify α φ')
⊢ φ ≫ τ.hom =
    φ ≫
      (toPresheaf (R.obj (P := Presheaf.IsSheaf J))).map
        ((Equiv.symm (sheafifyHomEquiv' α φ ⋯) :
            (a : M₀ ⟶ (sheafify α φ').val.restrictScalarsObj α) → (sheafify α φ).val ⟶ (sheafify α φ').val)
          (τ₀ ≫ toSheafify α φ'))

Tactic:
erw [comp_toPresheaf_map_sheafifyHomEquiv'_symm_hom]

Premises used: PresheafOfModules.comp_toPresheaf_map_sheafifyHomEquiv'_symm_hom
-- Module: Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify
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) φ
inst_5 :
  J.WEqualsLocallyBijective AddCommGrpCat (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v))
    (CA := AddCommGrpCat.carrier)
M₀' : PresheafOfModules.{v, v₁, u₁, u} R₀
A' : Sheaf J AddCommGrpCat
φ' : M₀'.presheaf ⟶ A'.obj (P := Presheaf.IsSheaf J)
inst_6 :
  Presheaf.IsLocallyInjective (FD := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CD :=
    AddCommGrpCat.carrier) J φ'
inst_7 :
  Presheaf.IsLocallySurjective J (FA := fun (x1 x2 : AddCommGrpCat.{v}) ↦ (↑x1 : Type v) →+ (↑x2 : Type v)) (CA :=
    AddCommGrpCat.carrier) φ'
τ₀ : M₀ ⟶ M₀'
τ : A ⟶ A'
fac : (toPresheaf R₀).map τ₀ ≫ φ' = φ ≫ τ.hom
X : Cᵒᵖ
r : (↑(R.obj (P := Presheaf.IsSheaf J).obj X) : Type u)
m : (↑((sheafify α φ).val.obj X) : Type v)
f : (sheafify α φ).val ⟶ (sheafify α φ').val :=
  (Equiv.symm (sheafifyHomEquiv' α φ ⋯) :
      (a : M₀ ⟶ (restrictScalars α).obj (sheafify α φ').val) → (sheafify α φ).val ⟶ (sheafify α φ').val)
    (τ₀ ≫ toSheafify α φ')
a : (toPresheaf R₀).map τ₀ ≫ φ' = (toPresheaf R₀).map (τ₀ ≫ toSheafify α φ')
a₁ : (toPresheaf R₀).map τ₀ ≫ φ' = (toPresheaf R₀).map τ₀ ≫ (toPresheaf R₀).map (toSheafify α φ')
a₂ a₃ : (toPresheaf R₀).map τ₀ ≫ φ' = (toPresheaf R₀).map τ₀ ≫ φ'
⊢ φ ≫ τ.hom = (toPresheaf R₀).map (τ₀ ≫ toSheafify α φ')

Tactic:
rw [← fac, Functor.map_comp, toPresheaf_map_toSheafify]

Premises used: PresheafOfModules.toPresheaf_map_toSheafify, CategoryTheory.Functor.map_comp
-- Module: Mathlib.Algebra.Category.ModuleCat.Presheaf
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
R : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
M : PresheafOfModules.{v, v₁, u₁, u} R
X Y : Cᵒᵖ
f : X ⟶ Y
r : (↑(R.obj X) : Type u)
m : (↑(M.obj X) : Type v)
⊢ (ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj X) : Type u)) ↦
          LinearMap.{u, u, v, v} (R := (↑(R.obj X) : Type u)) (RingHom.id (↑(R.obj X) : Type u)) (↑x1 : Type v)
            (↑x2 : Type v))
          (CC := ModuleCat.carrier) (M.map f) :
        (a : (↑(M.obj X) : Type v)) →
          (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).obj (M.obj Y)) : Type v))
      (r • m) =
    HSMul.hSMul (α := (↑(R.obj Y) : Type u)) (β :=
      (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).obj (M.obj Y)) : Type v))
      ((ConcreteCategory.hom (FC := fun (R S : RingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC := RingCat.carrier)
              (R.map f) :
            (a : (↑(R.obj X) : Type u)) → (↑(R.obj Y) : Type u))
          r :
        (↑(R.obj Y) : Type u))
      ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj X) : Type u)) ↦
              LinearMap.{u, u, v, v} (R := (↑(R.obj X) : Type u)) (RingHom.id (↑(R.obj X) : Type u)) (↑x1 : Type v)
                (↑x2 : Type v))
              (CC := ModuleCat.carrier) (M.map f) :
            (a : (↑(M.obj X) : Type v)) →
              (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).obj (M.obj Y)) : Type v))
          m :
        (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).obj (M.obj Y)) : Type v))

Tactic:
simp
-- Module: Mathlib.Algebra.Category.ModuleCat.Presheaf
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
R : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
M : PresheafOfModules.{v, v₁, u₁, u} R
X Y : Cᵒᵖ
f g : X ⟶ Y
h : f = g
m : (↑(M.obj X) : Type v)
rw rw₁ :
  Eq (α := (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map g))).obj (M.obj Y)) : Type v))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj X) : Type u)) ↦
            LinearMap.{u, u, v, v} (R := (↑(R.obj X) : Type u)) (RingHom.id (↑(R.obj X) : Type u)) (↑x1 : Type v)
              (↑x2 : Type v))
            (CC := ModuleCat.carrier) (M.map g) :
          (a : (↑(M.obj X) : Type v)) →
            (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map g))).obj (M.obj Y)) : Type v))
        m :
      (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map g))).obj (M.obj Y)) : Type v))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj X) : Type u)) ↦
            LinearMap.{u, u, v, v} (R := (↑(R.obj X) : Type u)) (RingHom.id (↑(R.obj X) : Type u)) (↑x1 : Type v)
              (↑x2 : Type v))
            (CC := ModuleCat.carrier) (M.map g) :
          (a : (↑(M.obj X) : Type v)) →
            (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map g))).obj (M.obj Y)) : Type v))
        m :
      (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map g))).obj (M.obj Y)) : Type v))
⊢ Eq (α := (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).obj (M.obj Y)) : Type v))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj X) : Type u)) ↦
            LinearMap.{u, u, v, v} (R := (↑(R.obj X) : Type u)) (RingHom.id (↑(R.obj X) : Type u)) (↑x1 : Type v)
              (↑x2 : Type v))
            (CC := ModuleCat.carrier) (M.map f) :
          (a : (↑(M.obj X) : Type v)) →
            (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).obj (M.obj Y)) : Type v))
        m :
      (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).obj (M.obj Y)) : Type v))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj X) : Type u)) ↦
            LinearMap.{u, u, v, v} (R := (↑(R.obj X) : Type u)) (RingHom.id (↑(R.obj X) : Type u)) (↑x1 : Type v)
              (↑x2 : Type v))
            (CC := ModuleCat.carrier) (M.map g) :
          (a : (↑(M.obj X) : Type v)) →
            (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map g))).obj (M.obj Y)) : Type v))
        m :
      (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map g))).obj (M.obj Y)) : Type v))

Tactic:
rw [h]
-- Module: Mathlib.Algebra.Category.ModuleCat.Presheaf
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
R : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
M : PresheafOfModules.{v, v₁, u₁, u} R
U V W : Cᵒᵖ
i : U ⟶ V
j : V ⟶ W
x : (↑(M.obj U) : Type v)
⊢ Eq (α := (↑(Functor.obj (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map (i ≫ j)))) (M.obj W)) : Type v))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj U) : Type u)) ↦
            LinearMap.{u, u, v, v} (R := (↑(R.obj U) : Type u)) (RingHom.id (↑(R.obj U) : Type u)) (↑x1 : Type v)
              (↑x2 : Type v))
            (CC := ModuleCat.carrier) (Y :=
            Functor.obj (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map (i ≫ j)))) (M.obj W))
            (M.map i ≫
              (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map i))).map (M.map j) ≫
                NatTrans.app
                  (Iso.inv
                    (ModuleCat.restrictScalarsComp' (RingCat.Hom.hom (R.map i)) (RingCat.Hom.hom (R.map j))
                      (RingCat.Hom.hom (R.map (i ≫ j))) ⋯))
                  (M.obj W)) :
          (a : (↑(M.obj U) : Type v)) →
            (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map (i ≫ j)))).obj (M.obj W)) : Type v))
        x :
      (↑(Functor.obj (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map (i ≫ j)))) (M.obj W)) : Type v))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj V) : Type u)) ↦
            LinearMap.{u, u, v, v} (R := (↑(R.obj V) : Type u)) (RingHom.id (↑(R.obj V) : Type u)) (↑x1 : Type v)
              (↑x2 : Type v))
            (CC := ModuleCat.carrier) (M.map j) :
          (a : (↑(M.obj V) : Type v)) →
            (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map j))).obj (M.obj W)) : Type v))
        ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj U) : Type u)) ↦
                LinearMap.{u, u, v, v} (R := (↑(R.obj U) : Type u)) (RingHom.id (↑(R.obj U) : Type u)) (↑x1 : Type v)
                  (↑x2 : Type v))
                (CC := ModuleCat.carrier) (M.map i) :
              (a : (↑(M.obj U) : Type v)) →
                (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map i))).obj (M.obj V)) : Type v))
            x :
          (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map i))).obj (M.obj V)) : Type v)) :
      (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map j))).obj (M.obj W)) : Type v))

Tactic:
rfl
-- Module: Mathlib.Algebra.Category.ModuleCat.Presheaf
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
R : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
M₁ M₂ : PresheafOfModules.{v, v₁, u₁, u} R
f g : M₁ ⟶ M₂
h h₁ : ∀ (x : Cᵒᵖ), f.app x = g.app x
⊢ f.app = g.app

Tactic:
ext1
-- Module: Mathlib.Algebra.Category.ModuleCat.Presheaf
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
R : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
M₁ M₂ : PresheafOfModules.{v, v₁, u₁, u} R
f g : M₁ ⟶ M₂
h : ∀ (X : Cᵒᵖ), f.app X = g.app X
x : Cᵒᵖ
⊢ f.app x = g.app x

Tactic:
apply h
-- Module: Mathlib.Algebra.Category.ModuleCat.Presheaf
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
R : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
M : PresheafOfModules.{u_1, v₁, u₁, u} R
X : Cᵒᵖ
⊢ Hom.app (𝟙 M) X = 𝟙 (M.obj X)

Tactic:
rfl
-- Module: Mathlib.Algebra.Category.ModuleCat.Presheaf
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
R : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
M₁ M₂ M₃ : PresheafOfModules.{u_1, v₁, u₁, u} R
f : M₁ ⟶ M₂
g : M₂ ⟶ M₃
X : Cᵒᵖ
⊢ (f ≫ g).app X = f.app X ≫ g.app X

Tactic:
rfl
-- Module: Mathlib.Algebra.Category.ModuleCat.Presheaf
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
R : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
M₁ M₂ : PresheafOfModules.{v, v₁, u₁, u} R
f : M₁ ⟶ M₂
X Y : Cᵒᵖ
g : X ⟶ Y
x : (↑(M₁.obj X) : Type v)
⊢ Eq (α := (↑(M₂.obj Y) : Type v))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj Y) : Type u)) ↦
            LinearMap.{u, u, v, v} (R := (↑(R.obj Y) : Type u)) (RingHom.id (↑(R.obj Y) : Type u)) (↑x1 : Type v)
              (↑x2 : Type v))
            (CC := ModuleCat.carrier) (f.app Y) :
          (a : (↑(M₁.obj Y) : Type v)) → (↑(M₂.obj Y) : Type v))
        ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj X) : Type u)) ↦
                LinearMap.{u, u, v, v} (R := (↑(R.obj X) : Type u)) (RingHom.id (↑(R.obj X) : Type u)) (↑x1 : Type v)
                  (↑x2 : Type v))
                (CC := ModuleCat.carrier) (M₁.map g) :
              (a : (↑(M₁.obj X) : Type v)) →
                (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map g))).obj (M₁.obj Y)) : Type v))
            x :
          (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map g))).obj (M₁.obj Y)) : Type v)) :
      (↑(M₂.obj Y) : Type v))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj X) : Type u)) ↦
            LinearMap.{u, u, v, v} (R := (↑(R.obj X) : Type u)) (RingHom.id (↑(R.obj X) : Type u)) (↑x1 : Type v)
              (↑x2 : Type v))
            (CC := ModuleCat.carrier) (M₂.map g) :
          (a : (↑(M₂.obj X) : Type v)) →
            (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map g))).obj (M₂.obj Y)) : Type v))
        ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj X) : Type u)) ↦
                LinearMap.{u, u, v, v} (R := (↑(R.obj X) : Type u)) (RingHom.id (↑(R.obj X) : Type u)) (↑x1 : Type v)
                  (↑x2 : Type v))
                (CC := ModuleCat.carrier) (f.app X) :
              (a : (↑(M₁.obj X) : Type v)) → (↑(M₂.obj X) : Type v))
            x :
          (↑(M₂.obj X) : Type v)) :
      (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map g))).obj (M₂.obj Y)) : Type v))

Tactic:
CategoryTheory.congr_fun (Hom.naturality f g) x

Premises used: CategoryTheory.congr_fun, PresheafOfModules.Hom.naturality
-- Module: Mathlib.Algebra.Category.ModuleCat.Presheaf
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
R : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
M : PresheafOfModules.{v, v₁, u₁, u} R
X : Cᵒᵖ
⊢ (↑(M.presheaf.obj X) : Type v) = (↑(M.obj X) : Type v)

Tactic:
rfl

Premises used: rfl
-- Module: Mathlib.Algebra.Category.ModuleCat.Presheaf
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
R : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
M : PresheafOfModules.{v, v₁, u₁, u} R
X Y : Cᵒᵖ
f : X ⟶ Y
x : (↑(M.obj X) : Type v)
⊢ Eq (α := (↑(M.obj Y) : Type v))
    ((AddCommGrpCat.Hom.hom (M.presheaf.map f) : (a : (↑(M.obj X) : Type v)) → (↑(M.obj Y) : Type v)) x :
      (↑(M.obj Y) : Type v))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj X) : Type u)) ↦
            LinearMap.{u, u, v, v} (R := (↑(R.obj X) : Type u)) (RingHom.id (↑(R.obj X) : Type u)) (↑x1 : Type v)
              (↑x2 : Type v))
            (CC := ModuleCat.carrier) (M.map f) :
          (a : (↑(M.obj X) : Type v)) →
            (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).obj (M.obj Y)) : Type v))
        x :
      (↑((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).obj (M.obj Y)) : Type v))

Tactic:
rfl

Premises used: rfl
-- Module: Mathlib.Algebra.Category.ModuleCat.Presheaf
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
R : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
M M₁ M₂ X_1 Y : PresheafOfModules.{v, v₁, u₁, u} R
f : X_1 ⟶ Y
X : Cᵒᵖ
⊢ ∀ (a b : (↑(X_1.obj X) : Type v)),
    (ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj X) : Type u)) ↦
            LinearMap.{u, u, v, v} (R := (↑(R.obj X) : Type u)) (RingHom.id (↑(R.obj X) : Type u)) (↑x1 : Type v)
              (↑x2 : Type v))
            (CC := ModuleCat.carrier) (f.app X) :
          (a : (↑(X_1.obj X) : Type v)) → (↑(Y.obj X) : Type v))
        (a + b) =
      HAdd.hAdd (α := (↑(Y.obj X) : Type v)) (β := (↑(Y.obj X) : Type v))
        ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj X) : Type u)) ↦
                LinearMap.{u, u, v, v} (R := (↑(R.obj X) : Type u)) (RingHom.id (↑(R.obj X) : Type u)) (↑x1 : Type v)
                  (↑x2 : Type v))
                (CC := ModuleCat.carrier) (f.app X) :
              (a : (↑(X_1.obj X) : Type v)) → (↑(Y.obj X) : Type v))
            a :
          (↑(Y.obj X) : Type v))
        ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj X) : Type u)) ↦
                LinearMap.{u, u, v, v} (R := (↑(R.obj X) : Type u)) (RingHom.id (↑(R.obj X) : Type u)) (↑x1 : Type v)
                  (↑x2 : Type v))
                (CC := ModuleCat.carrier) (f.app X) :
              (a : (↑(X_1.obj X) : Type v)) → (↑(Y.obj X) : Type v))
            b :
          (↑(Y.obj X) : Type v))

Tactic:
simp
-- Module: Mathlib.Algebra.Category.ModuleCat.Presheaf
Goal:
C : Type u₁
inst : Category.{v₁, u₁} C
R : CategoryTheory.Functor.{v₁, u, u₁, u + 1} Cᵒᵖ RingCat
M M₁ M₂ X_1 Y_1 : PresheafOfModules.{v, v₁, u₁, u} R
f : X_1 ⟶ Y_1
X Y : Cᵒᵖ
g : X ⟶ Y
hf :
  ∀ (x : (↑(X_1.presheaf.obj X) : Type v)),
    Eq (α := (↑(Y_1.presheaf.obj Y) : Type v))
      ((AddCommGrpCat.Hom.hom
              (X_1.presheaf.map g ≫
                AddCommGrpCat.ofHom
                  (AddMonoidHom.mk'
                    (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj Y) : Type u)) ↦
                          LinearMap.{u, u, v, v} (R := (↑(R.obj Y) : Type u)) (RingHom.id (↑(R.obj Y) : Type u))
                            (↑x1 : Type v) (↑x2 : Type v))
                          (CC := ModuleCat.carrier) (f.app Y)) :
                      (a : (↑(X_1.obj Y) : Type v)) → (↑(Y_1.obj Y) : Type v))
                    ⋯)) :
            (a : (↑(X_1.presheaf.obj X) : Type v)) → (↑(Y_1.presheaf.obj Y) : Type v))
          x :
        (↑(Y_1.presheaf.obj Y) : Type v))
      ((AddCommGrpCat.Hom.hom
              (AddCommGrpCat.ofHom
                  (AddMonoidHom.mk'
                    (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj X) : Type u)) ↦
                          LinearMap.{u, u, v, v} (R := (↑(R.obj X) : Type u)) (RingHom.id (↑(R.obj X) : Type u))
                            (↑x1 : Type v) (↑x2 : Type v))
                          (CC := ModuleCat.carrier) (f.app X)) :
                      (a : (↑(X_1.obj X) : Type v)) → (↑(Y_1.obj X) : Type v))
                    ⋯) ≫
                Y_1.presheaf.map g) :
            (a : (↑(X_1.presheaf.obj X) : Type v)) → (↑(Y_1.presheaf.obj Y) : Type v))
          x :
        (↑(Y_1.presheaf.obj Y) : Type v))
⊢ X_1.presheaf.map g ≫
      AddCommGrpCat.ofHom
        (AddMonoidHom.mk'
          (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj Y) : Type u)) ↦
                LinearMap.{u, u, v, v} (R := (↑(R.obj Y) : Type u)) (RingHom.id (↑(R.obj Y) : Type u)) (↑x1 : Type v)
                  (↑x2 : Type v))
                (CC := ModuleCat.carrier) (f.app Y)) :
            (a : (↑(X_1.obj Y) : Type v)) → (↑(Y_1.obj Y) : Type v))
          ⋯) =
    AddCommGrpCat.ofHom
        (AddMonoidHom.mk'
          (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} (↑(R.obj X) : Type u)) ↦
                LinearMap.{u, u, v, v} (R := (↑(R.obj X) : Type u)) (RingHom.id (↑(R.obj X) : Type u)) (↑x1 : Type v)
                  (↑x2 : Type v))
                (CC := ModuleCat.carrier) (f.app X)) :
            (a : (↑(X_1.obj X) : Type v)) → (↑(Y_1.obj X) : Type v))
          ⋯) ≫
      Y_1.presheaf.map g

Tactic:
ext x