-- Mathlib/CategoryTheory/Sites/EqualizerSheafCondition.lean
theorem w : forkMap P R ≫ firstMap P R = forkMap P R ≫ secondMap P R

Proof state:
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
inst✝ : R.hasPullbacks
fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }
a✝ : P.obj (op X)
⊢ (P.map (↑fg.1.snd).op ≫ P.map (pullback.fst ↑fg.1.snd ↑fg.2.snd).op) a✝ =
    (P.map (↑fg.2.snd).op ≫ P.map (pullback.snd ↑fg.1.snd ↑fg.2.snd).op) a✝

Tactic:
haveI := Presieve.hasPullbacks.has_pullbacks fg.1.2.2 fg.2.2.2

Result:
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
inst✝ : R.hasPullbacks
fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }
a✝ : P.obj (op X)
this : HasPullback ↑fg.1.snd ↑fg.2.snd
⊢ (P.map (↑fg.1.snd).op ≫ P.map (pullback.fst ↑fg.1.snd ↑fg.2.snd).op) a✝ =
    (P.map (↑fg.2.snd).op ≫ P.map (pullback.snd ↑fg.1.snd ↑fg.2.snd).op) a✝

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
inst✝ : R.hasPullbacks
⊢ forkMap P R ≫ firstMap P R = forkMap P R ≫ secondMap P R

Tactic:
ext fg

Result:
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
inst✝ : R.hasPullbacks
fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }
a✝ : P.obj (op X)
⊢ ((forkMap P R ≫ firstMap P R) ≫ Pi.π (fun fg => P.obj (op (Limits.pullback ↑fg.1.snd ↑fg.2.snd))) fg) a✝ =
    ((forkMap P R ≫ secondMap P R) ≫ Pi.π (fun fg => P.obj (op (Limits.pullback ↑fg.1.snd ↑fg.2.snd))) fg) a✝

Proof state:
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
inst✝ : R.hasPullbacks
fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }
a✝ : P.obj (op X)
this : HasPullback ↑fg.1.snd ↑fg.2.snd
⊢ (P.map (↑fg.1.snd).op ≫ P.map (pullback.fst ↑fg.1.snd ↑fg.2.snd).op) a✝ =
    (P.map (↑fg.2.snd).op ≫ P.map (pullback.snd ↑fg.1.snd ↑fg.2.snd).op) a✝

Tactic:
rw [← P.map_comp, ← op_comp, pullback.condition]

Result:
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
inst✝ : R.hasPullbacks
fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }
a✝ : P.obj (op X)
this : HasPullback ↑fg.1.snd ↑fg.2.snd
⊢ P.map (pullback.snd ↑fg.1.snd ↑fg.2.snd ≫ ↑fg.2.snd).op a✝ =
    (P.map (↑fg.2.snd).op ≫ P.map (pullback.snd ↑fg.1.snd ↑fg.2.snd).op) a✝

Proof state:
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
inst✝ : R.hasPullbacks
fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }
a✝ : P.obj (op X)
⊢ ((forkMap P R ≫ firstMap P R) ≫ Pi.π (fun fg => P.obj (op (Limits.pullback ↑fg.1.snd ↑fg.2.snd))) fg) a✝ =
    ((forkMap P R ≫ secondMap P R) ≫ Pi.π (fun fg => P.obj (op (Limits.pullback ↑fg.1.snd ↑fg.2.snd))) fg) a✝

Tactic:
simp only [firstMap, secondMap, forkMap]

Result:
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
inst✝ : R.hasPullbacks
fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }
a✝ : P.obj (op X)
⊢ (((Pi.lift fun f => P.map (↑f.snd).op) ≫
          Pi.lift fun fg => Pi.π (fun f => P.obj (op f.fst)) fg.1 ≫ P.map (pullback.fst ↑fg.1.snd ↑fg.2.snd).op) ≫
        Pi.π (fun fg => P.obj (op (Limits.pullback ↑fg.1.snd ↑fg.2.snd))) fg)
      a✝ =
    (((Pi.lift fun f => P.map (↑f.snd).op) ≫
          Pi.lift fun fg => Pi.π (fun f => P.obj (op f.fst)) fg.2 ≫ P.map (pullback.snd ↑fg.1.snd ↑fg.2.snd).op) ≫
        Pi.π (fun fg => P.obj (op (Limits.pullback ↑fg.1.snd ↑fg.2.snd))) fg)
      a✝

Proof state:
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
inst✝ : R.hasPullbacks
fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }
a✝ : P.obj (op X)
⊢ (((Pi.lift fun f => P.map (↑f.snd).op) ≫
          Pi.lift fun fg => Pi.π (fun f => P.obj (op f.fst)) fg.1 ≫ P.map (pullback.fst ↑fg.1.snd ↑fg.2.snd).op) ≫
        Pi.π (fun fg => P.obj (op (Limits.pullback ↑fg.1.snd ↑fg.2.snd))) fg)
      a✝ =
    (((Pi.lift fun f => P.map (↑f.snd).op) ≫
          Pi.lift fun fg => Pi.π (fun f => P.obj (op f.fst)) fg.2 ≫ P.map (pullback.snd ↑fg.1.snd ↑fg.2.snd).op) ≫
        Pi.π (fun fg => P.obj (op (Limits.pullback ↑fg.1.snd ↑fg.2.snd))) fg)
      a✝

Tactic:
simp only [limit.lift_π, limit.lift_π_assoc, assoc, Fan.mk_π_app]

Result:
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
inst✝ : R.hasPullbacks
fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }
a✝ : P.obj (op X)
⊢ (P.map (↑fg.1.snd).op ≫ P.map (pullback.fst ↑fg.1.snd ↑fg.2.snd).op) a✝ =
    (P.map (↑fg.2.snd).op ≫ P.map (pullback.snd ↑fg.1.snd ↑fg.2.snd).op) a✝

Proof state:
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
inst✝ : R.hasPullbacks
fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }
a✝ : P.obj (op X)
this : HasPullback ↑fg.1.snd ↑fg.2.snd
⊢ P.map (pullback.snd ↑fg.1.snd ↑fg.2.snd ≫ ↑fg.2.snd).op a✝ =
    (P.map (↑fg.2.snd).op ≫ P.map (pullback.snd ↑fg.1.snd ↑fg.2.snd).op) a✝

Tactic:
simp

Result:
no goals