Theorem: CategoryTheory.Presieve.FamilyOfElements.isCompatible_map_smul
File: Mathlib/Algebra/Category/ModuleCat/Presheaf/Sheafify.lean

tactic: intro Y₁ Y₂ Z g₁ g₂ f₁ f₂ h₁ h₂ fac
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
⊢ ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp))).Compatible
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)

tactic: let a₁ := r₀ f₁ h₁
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)

tactic: let b₁ := m₀ f₁ h₁
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)

tactic: let a₂ := r₀ f₂ h₂
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)

tactic: let b₂ := m₀ f₂ h₂
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)

tactic: let a₀ := R₀.map g₁.op a₁
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)

tactic: let b₀ := M₀.map g₁.op b₁
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)

tactic: have ha₁ : (α.app (Opposite.op Y₁)) a₁ = (R.map f₁.op) r := (hr₀ f₁ h₁).symm
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)

tactic: have ha₂ : (α.app (Opposite.op Y₂)) a₂ = (R.map f₂.op) r := (hr₀ f₂ h₂).symm
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)

tactic: have hb₁ : (φ.app (Opposite.op Y₁)) b₁ = (A.map f₁.op) m := (hm₀ f₁ h₁).symm
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)

tactic: have hb₂ : (φ.app (Opposite.op Y₂)) b₂ = (A.map f₂.op) m := (hm₀ f₂ h₂).symm
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)

tactic: have ha₀ : (α.app (Opposite.op Z)) a₀ = (R.map (f₁.op ≫ g₁.op)) r := by
  dsimp [a₀]
  rw [NatTrans.naturality_apply, ha₁, Functor.map_comp, comp_apply]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)

tactic: have hb₀ : (φ.app (Opposite.op Z)) b₀ = (A.map (f₁.op ≫ g₁.op)) m := by
  dsimp [b₀]
  erw [NatTrans.naturality_apply, hb₁, Functor.map_comp, comp_apply]
  rfl
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
hb₀ : (φ.app { unop := Z }) b₀ = (A.map (f₁.op ≫ g₁.op)) m
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)

tactic: have ha₀' : (α.app (Opposite.op Z)) a₀ = (R.map (f₂.op ≫ g₂.op)) r := by
  rw [ha₀, ← op_comp, fac, op_comp]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
hb₀ : (φ.app { unop := Z }) b₀ = (A.map (f₁.op ≫ g₁.op)) m
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
hb₀ : (φ.app { unop := Z }) b₀ = (A.map (f₁.op ≫ g₁.op)) m
ha₀' : (α.app { unop := Z }) a₀ = (R.map (f₂.op ≫ g₂.op)) r
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)

tactic: have hb₀' : (φ.app (Opposite.op Z)) b₀ = (A.map (f₂.op ≫ g₂.op)) m := by
  rw [hb₀, ← op_comp, fac, op_comp]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
hb₀ : (φ.app { unop := Z }) b₀ = (A.map (f₁.op ≫ g₁.op)) m
ha₀' : (α.app { unop := Z }) a₀ = (R.map (f₂.op ≫ g₂.op)) r
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
hb₀ : (φ.app { unop := Z }) b₀ = (A.map (f₁.op ≫ g₁.op)) m
ha₀' : (α.app { unop := Z }) a₀ = (R.map (f₂.op ≫ g₂.op)) r
hb₀' : (φ.app { unop := Z }) b₀ = (A.map (f₂.op ≫ g₂.op)) m
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)

tactic: dsimp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
hb₀ : (φ.app { unop := Z }) b₀ = (A.map (f₁.op ≫ g₁.op)) m
ha₀' : (α.app { unop := Z }) a₀ = (R.map (f₂.op ≫ g₂.op)) r
hb₀' : (φ.app { unop := Z }) b₀ = (A.map (f₂.op ≫ g₂.op)) m
⊢ (A ⋙ forget AddCommGrp).map g₁.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₁ h₁) =
    (A ⋙ forget AddCommGrp).map g₂.op ((r₀.smul m₀).map (whiskerRight φ (forget AddCommGrp)) f₂ h₂)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
hb₀ : (φ.app { unop := Z }) b₀ = (A.map (f₁.op ≫ g₁.op)) m
ha₀' : (α.app { unop := Z }) a₀ = (R.map (f₂.op ≫ g₂.op)) r
hb₀' : (φ.app { unop := Z }) b₀ = (A.map (f₂.op ≫ g₂.op)) m
⊢ (A.map g₁.op) ((φ.app { unop := Y₁ }) (r₀.smul m₀ f₁ h₁)) = (A.map g₂.op) ((φ.app { unop := Y₂ }) (r₀.smul m₀ f₂ h₂))

tactic: erw [← NatTrans.naturality_apply, ← NatTrans.naturality_apply]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
hb₀ : (φ.app { unop := Z }) b₀ = (A.map (f₁.op ≫ g₁.op)) m
ha₀' : (α.app { unop := Z }) a₀ = (R.map (f₂.op ≫ g₂.op)) r
hb₀' : (φ.app { unop := Z }) b₀ = (A.map (f₂.op ≫ g₂.op)) m
⊢ (A.map g₁.op) ((φ.app { unop := Y₁ }) (r₀.smul m₀ f₁ h₁)) = (A.map g₂.op) ((φ.app { unop := Y₂ }) (r₀.smul m₀ f₂ h₂))
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
hb₀ : (φ.app { unop := Z }) b₀ = (A.map (f₁.op ≫ g₁.op)) m
ha₀' : (α.app { unop := Z }) a₀ = (R.map (f₂.op ≫ g₂.op)) r
hb₀' : (φ.app { unop := Z }) b₀ = (A.map (f₂.op ≫ g₂.op)) m
⊢ (φ.app { unop := Z }) ((M₀.presheaf.map g₁.op) (r₀.smul m₀ f₁ h₁)) =
    (φ.app { unop := Z }) ((M₀.presheaf.map g₂.op) (r₀.smul m₀ f₂ h₂))

tactic: exact (isCompatible_map_smul_aux α φ hA r m f₁ g₁ a₁ a₀ b₁ b₀ ha₁ ha₀ hb₁ hb₀).trans
  (isCompatible_map_smul_aux α φ hA r m f₂ g₂ a₂ a₀ b₂ b₀ ha₂ ha₀' hb₂ hb₀').symm
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
hb₀ : (φ.app { unop := Z }) b₀ = (A.map (f₁.op ≫ g₁.op)) m
ha₀' : (α.app { unop := Z }) a₀ = (R.map (f₂.op ≫ g₂.op)) r
hb₀' : (φ.app { unop := Z }) b₀ = (A.map (f₂.op ≫ g₂.op)) m
⊢ (φ.app { unop := Z }) ((M₀.presheaf.map g₁.op) (r₀.smul m₀ f₁ h₁)) =
    (φ.app { unop := Z }) ((M₀.presheaf.map g₂.op) (r₀.smul m₀ f₂ h₂))
state_after: no goals

tactic: dsimp [a₀]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
⊢ (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
⊢ (α.app { unop := Z }) ((R₀.map g₁.op) a₁) = (R.map (f₁.op ≫ g₁.op)) r

tactic: rw [NatTrans.naturality_apply, ha₁, Functor.map_comp, comp_apply]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
⊢ (α.app { unop := Z }) ((R₀.map g₁.op) a₁) = (R.map (f₁.op ≫ g₁.op)) r
state_after: no goals

tactic: dsimp [b₀]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
⊢ (φ.app { unop := Z }) b₀ = (A.map (f₁.op ≫ g₁.op)) m
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
⊢ (φ.app { unop := Z }) ((M₀.map g₁.op) b₁) = (A.map (f₁.op ≫ g₁.op)) m

tactic: erw [NatTrans.naturality_apply, hb₁, Functor.map_comp, comp_apply]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
⊢ (φ.app { unop := Z }) ((M₀.map g₁.op) b₁) = (A.map (f₁.op ≫ g₁.op)) m
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
⊢ (A.map g₁.op) ((A.map f₁.op) m) = (A.map g₁.op) ((A.map f₁.op) m)

tactic: rfl
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
⊢ (A.map g₁.op) ((A.map f₁.op) m) = (A.map g₁.op) ((A.map f₁.op) m)
state_after: no goals

tactic: rw [ha₀, ← op_comp, fac, op_comp]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
hb₀ : (φ.app { unop := Z }) b₀ = (A.map (f₁.op ≫ g₁.op)) m
⊢ (α.app { unop := Z }) a₀ = (R.map (f₂.op ≫ g₂.op)) r
state_after: no goals

tactic: rw [hb₀, ← op_comp, fac, op_comp]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : GrothendieckTopology C
R₀ R : Cᵒᵖ ⥤ RingCat
α : R₀ ⟶ R
inst✝¹ : Presheaf.IsLocallyInjective J α
M₀ : PresheafOfModules R₀
A : Cᵒᵖ ⥤ AddCommGrp
φ : M₀.presheaf ⟶ A
inst✝ : Presheaf.IsLocallyInjective J φ
hA : Presheaf.IsSeparated J A
X : C
r : ↑(R.obj { unop := X })
m : ↑(A.obj { unop := X })
P : Presieve X
r₀ : FamilyOfElements (R₀ ⋙ forget RingCat) P
m₀ : FamilyOfElements (M₀.presheaf ⋙ forget AddCommGrp) P
hr₀ : (r₀.map (whiskerRight α (forget RingCat))).IsAmalgamation r
hm₀ : (m₀.map (whiskerRight φ (forget AddCommGrp))).IsAmalgamation m
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : P f₁
h₂ : P f₂
fac : g₁ ≫ f₁ = g₂ ≫ f₂
a₁ : (R₀ ⋙ forget RingCat).obj { unop := Y₁ } := r₀ f₁ h₁
b₁ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₁ } := m₀ f₁ h₁
a₂ : (R₀ ⋙ forget RingCat).obj { unop := Y₂ } := r₀ f₂ h₂
b₂ : (M₀.presheaf ⋙ forget AddCommGrp).obj { unop := Y₂ } := m₀ f₂ h₂
a₀ : ↑(R₀.obj { unop := Z }) := (R₀.map g₁.op) a₁
b₀ : ↑(M₀.obj { unop := Z }) := (M₀.map g₁.op) b₁
ha₁ : (α.app { unop := Y₁ }) a₁ = (R.map f₁.op) r
ha₂ : (α.app { unop := Y₂ }) a₂ = (R.map f₂.op) r
hb₁ : (φ.app { unop := Y₁ }) b₁ = (A.map f₁.op) m
hb₂ : (φ.app { unop := Y₂ }) b₂ = (A.map f₂.op) m
ha₀ : (α.app { unop := Z }) a₀ = (R.map (f₁.op ≫ g₁.op)) r
hb₀ : (φ.app { unop := Z }) b₀ = (A.map (f₁.op ≫ g₁.op)) m
ha₀' : (α.app { unop := Z }) a₀ = (R.map (f₂.op ≫ g₂.op)) r
⊢ (φ.app { unop := Z }) b₀ = (A.map (f₂.op ≫ g₂.op)) m
state_after: no goals