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

tactic: apply limit.hom_ext
state_before: C : Type u₁
inst✝¹ : Category C
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
X : C
R : Presieve X
S : Sieve X
inst✝ : HasPullbacks C
⊢ forkMap P R ≫ firstMap P R = forkMap P R ≫ secondMap P R

tactic: rintro ⟨⟨Y, f, hf⟩, ⟨Z, g, hg⟩⟩
state_before: case w
C : Type u₁
inst✝¹ : Category C
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
X : C
R : Presieve X
S : Sieve X
inst✝ : HasPullbacks C
⊢ ∀ (j : Discrete (((Y : C) × { f // R f }) × (Z : C) × { g // R g })),
    (forkMap P R ≫ firstMap P R) ≫
        limit.π (Discrete.functor fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op) j =
      (forkMap P R ≫ secondMap P R) ≫
        limit.π (Discrete.functor fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op) j

tactic: simp only [firstMap, secondMap, forkMap]
state_before: case w.mk.mk.mk.mk.mk.mk
C : Type u₁
inst✝¹ : Category C
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
X : C
R : Presieve X
S : Sieve X
inst✝ : HasPullbacks C
Y : C
f : Y ⟶ X
hf : R f
Z : C
g : Z ⟶ X
hg : R g
⊢ (forkMap P R ≫ firstMap P R) ≫
      limit.π (Discrete.functor fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
        {
          as :=
            ({ fst := Y, snd := { val := f, property := hf } }, { fst := Z, snd := { val := g, property := hg } }) } =
    (forkMap P R ≫ secondMap P R) ≫
      limit.π (Discrete.functor fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
        { as := ({ fst := Y, snd := { val := f, property := hf } }, { fst := Z, snd := { val := g, property := hg } }) }

tactic: simp only [limit.lift_π, limit.lift_π_assoc, assoc, Fan.mk_π_app]
state_before: case w.mk.mk.mk.mk.mk.mk
C : Type u₁
inst✝¹ : Category C
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
X : C
R : Presieve X
S : Sieve X
inst✝ : HasPullbacks C
Y : C
f : Y ⟶ X
hf : R f
Z : C
g : Z ⟶ X
hg : R g
⊢ ((Pi.lift fun f => P.map (↑f.snd).op) ≫
        Pi.lift fun x => Pi.π (fun f => P.obj f.fst.op) x.fst ≫ P.map pullback.fst.op) ≫
      limit.π (Discrete.functor fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
        {
          as :=
            ({ fst := Y, snd := { val := f, property := hf } }, { fst := Z, snd := { val := g, property := hg } }) } =
    ((Pi.lift fun f => P.map (↑f.snd).op) ≫
        Pi.lift fun x => Pi.π (fun f => P.obj f.fst.op) x.snd ≫ P.map pullback.snd.op) ≫
      limit.π (Discrete.functor fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
        { as := ({ fst := Y, snd := { val := f, property := hf } }, { fst := Z, snd := { val := g, property := hg } }) }

tactic: rw [← P.map_comp, ← op_comp, pullback.condition]
state_before: case w.mk.mk.mk.mk.mk.mk
C : Type u₁
inst✝¹ : Category C
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
X : C
R : Presieve X
S : Sieve X
inst✝ : HasPullbacks C
Y : C
f : Y ⟶ X
hf : R f
Z : C
g : Z ⟶ X
hg : R g
⊢ P.map f.op ≫ P.map pullback.fst.op = P.map g.op ≫ P.map pullback.snd.op

tactic: simp
state_before: case w.mk.mk.mk.mk.mk.mk
C : Type u₁
inst✝¹ : Category C
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
X : C
R : Presieve X
S : Sieve X
inst✝ : HasPullbacks C
Y : C
f : Y ⟶ X
hf : R f
Z : C
g : Z ⟶ X
hg : R g
⊢ P.map (pullback.snd ≫ g).op = P.map g.op ≫ P.map pullback.snd.op