Theorem: CategoryTheory.Equalizer.Presieve.w
File: Mathlib/CategoryTheory/Sites/EqualizerSheafCondition.lean

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

tactic: simp only [firstMap, secondMap, forkMap]
state_before: case h.h
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
inst✝ : R.hasPullbacks
fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }
a✝ : P.obj { unop := X }
⊢ ((forkMap P R ≫ firstMap P R) ≫ Pi.π (fun fg => P.obj { unop := Limits.pullback ↑fg.1.snd ↑fg.2.snd }) fg) a✝ =
    ((forkMap P R ≫ secondMap P R) ≫ Pi.π (fun fg => P.obj { unop := Limits.pullback ↑fg.1.snd ↑fg.2.snd }) fg) a✝
state_after: case h.h
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
inst✝ : R.hasPullbacks
fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }
a✝ : P.obj { unop := X }
⊢ (((Pi.lift fun f => P.map (↑f.snd).op) ≫
          Pi.lift fun fg => Pi.π (fun f => P.obj { unop := f.fst }) fg.1 ≫ P.map pullback.fst.op) ≫
        Pi.π (fun fg => P.obj { unop := 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 { unop := f.fst }) fg.2 ≫ P.map pullback.snd.op) ≫
        Pi.π (fun fg => P.obj { unop := Limits.pullback ↑fg.1.snd ↑fg.2.snd }) fg)
      a✝

tactic: simp only [limit.lift_π, limit.lift_π_assoc, assoc, Fan.mk_π_app]
state_before: case h.h
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
inst✝ : R.hasPullbacks
fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }
a✝ : P.obj { unop := X }
⊢ (((Pi.lift fun f => P.map (↑f.snd).op) ≫
          Pi.lift fun fg => Pi.π (fun f => P.obj { unop := f.fst }) fg.1 ≫ P.map pullback.fst.op) ≫
        Pi.π (fun fg => P.obj { unop := 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 { unop := f.fst }) fg.2 ≫ P.map pullback.snd.op) ≫
        Pi.π (fun fg => P.obj { unop := Limits.pullback ↑fg.1.snd ↑fg.2.snd }) fg)
      a✝
state_after: case h.h
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
inst✝ : R.hasPullbacks
fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }
a✝ : P.obj { unop := X }
⊢ (P.map (↑fg.1.snd).op ≫ P.map pullback.fst.op) a✝ = (P.map (↑fg.2.snd).op ≫ P.map pullback.snd.op) a✝

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

tactic: rw [← P.map_comp, ← op_comp, pullback.condition]
state_before: case h.h
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
inst✝ : R.hasPullbacks
fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }
a✝ : P.obj { unop := X }
this : HasPullback ↑fg.1.snd ↑fg.2.snd
⊢ (P.map (↑fg.1.snd).op ≫ P.map pullback.fst.op) a✝ = (P.map (↑fg.2.snd).op ≫ P.map pullback.snd.op) a✝
state_after: case h.h
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
inst✝ : R.hasPullbacks
fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }
a✝ : P.obj { unop := X }
this : HasPullback ↑fg.1.snd ↑fg.2.snd
⊢ P.map (pullback.snd ≫ ↑fg.2.snd).op a✝ = (P.map (↑fg.2.snd).op ≫ P.map pullback.snd.op) a✝

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