Theorem: CategoryTheory.Presieve.firstMap_eq_secondMap
File: Mathlib/CategoryTheory/Sites/Preserves.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
I : C
F : Cᵒᵖ ⥤ Type w
hF : IsSheafFor F (ofArrows Empty.elim fun a => instIsEmptyEmpty.elim a)
hI : IsInitial I
α : Type
X : α → C
c : Cofan X
hc : IsColimit c
inst✝² : (ofArrows X c.inj).hasPullbacks
inst✝¹ : HasInitial C
inst✝ : ∀ (i : α), Mono (c.inj i)
hd : Pairwise fun i j => IsPullback (initial.to (X i)) (initial.to (X j)) (c.inj i) (c.inj j)
⊢ Equalizer.Presieve.Arrows.firstMap F X c.inj = Equalizer.Presieve.Arrows.secondMap F X c.inj
state_after: case h.h.mk
C : Type u
inst✝³ : Category.{v, u} C
I : C
F : Cᵒᵖ ⥤ Type w
hF : IsSheafFor F (ofArrows Empty.elim fun a => instIsEmptyEmpty.elim a)
hI : IsInitial I
α : Type
X : α → C
c : Cofan X
hc : IsColimit c
inst✝² : (ofArrows X c.inj).hasPullbacks
inst✝¹ : HasInitial C
inst✝ : ∀ (i : α), Mono (c.inj i)
hd : Pairwise fun i j => IsPullback (initial.to (X i)) (initial.to (X j)) (c.inj i) (c.inj j)
a : Equalizer.Presieve.Arrows.FirstObj F X
i j : α
⊢ Pi.π (fun ij => F.obj (op (pullback (c.inj ij.1) (c.inj ij.2)))) (i, j)
      (Equalizer.Presieve.Arrows.firstMap F X c.inj a) =
    Pi.π (fun ij => F.obj (op (pullback (c.inj ij.1) (c.inj ij.2)))) (i, j)
      (Equalizer.Presieve.Arrows.secondMap F X c.inj a)
tactic: ext a ⟨i, j⟩
state_before: case h.h.mk
C : Type u
inst✝³ : Category.{v, u} C
I : C
F : Cᵒᵖ ⥤ Type w
hF : IsSheafFor F (ofArrows Empty.elim fun a => instIsEmptyEmpty.elim a)
hI : IsInitial I
α : Type
X : α → C
c : Cofan X
hc : IsColimit c
inst✝² : (ofArrows X c.inj).hasPullbacks
inst✝¹ : HasInitial C
inst✝ : ∀ (i : α), Mono (c.inj i)
hd : Pairwise fun i j => IsPullback (initial.to (X i)) (initial.to (X j)) (c.inj i) (c.inj j)
a : Equalizer.Presieve.Arrows.FirstObj F X
i j : α
⊢ Pi.π (fun ij => F.obj (op (pullback (c.inj ij.1) (c.inj ij.2)))) (i, j)
      (Equalizer.Presieve.Arrows.firstMap F X c.inj a) =
    Pi.π (fun ij => F.obj (op (pullback (c.inj ij.1) (c.inj ij.2)))) (i, j)
      (Equalizer.Presieve.Arrows.secondMap F X c.inj a)
state_after: case h.h.mk
C : Type u
inst✝³ : Category.{v, u} C
I : C
F : Cᵒᵖ ⥤ Type w
hF : IsSheafFor F (ofArrows Empty.elim fun a => instIsEmptyEmpty.elim a)
hI : IsInitial I
α : Type
X : α → C
c : Cofan X
hc : IsColimit c
inst✝² : (ofArrows X c.inj).hasPullbacks
inst✝¹ : HasInitial C
inst✝ : ∀ (i : α), Mono (c.inj i)
hd : Pairwise fun i j => IsPullback (initial.to (X i)) (initial.to (X j)) (c.inj i) (c.inj j)
a : Equalizer.Presieve.Arrows.FirstObj F X
i j : α
⊢ F.map (pullback.fst (c.inj i) (c.inj j)).op (Pi.π (fun i => F.obj (op (X i))) i a) =
    F.map (pullback.snd (c.inj i) (c.inj j)).op (Pi.π (fun i => F.obj (op (X i))) j a)
tactic: simp only [Equalizer.Presieve.Arrows.firstMap, Types.pi_lift_π_apply, types_comp_apply,
    Equalizer.Presieve.Arrows.secondMap]
state_before: case h.h.mk
C : Type u
inst✝³ : Category.{v, u} C
I : C
F : Cᵒᵖ ⥤ Type w
hF : IsSheafFor F (ofArrows Empty.elim fun a => instIsEmptyEmpty.elim a)
hI : IsInitial I
α : Type
X : α → C
c : Cofan X
hc : IsColimit c
inst✝² : (ofArrows X c.inj).hasPullbacks
inst✝¹ : HasInitial C
inst✝ : ∀ (i : α), Mono (c.inj i)
hd : Pairwise fun i j => IsPullback (initial.to (X i)) (initial.to (X j)) (c.inj i) (c.inj j)
a : Equalizer.Presieve.Arrows.FirstObj F X
i j : α
⊢ F.map (pullback.fst (c.inj i) (c.inj j)).op (Pi.π (fun i => F.obj (op (X i))) i a) =
    F.map (pullback.snd (c.inj i) (c.inj j)).op (Pi.π (fun i => F.obj (op (X i))) j a)
state_after: case pos
C : Type u
inst✝³ : Category.{v, u} C
I : C
F : Cᵒᵖ ⥤ Type w
hF : IsSheafFor F (ofArrows Empty.elim fun a => instIsEmptyEmpty.elim a)
hI : IsInitial I
α : Type
X : α → C
c : Cofan X
hc : IsColimit c
inst✝² : (ofArrows X c.inj).hasPullbacks
inst✝¹ : HasInitial C
inst✝ : ∀ (i : α), Mono (c.inj i)
hd : Pairwise fun i j => IsPullback (initial.to (X i)) (initial.to (X j)) (c.inj i) (c.inj j)
a : Equalizer.Presieve.Arrows.FirstObj F X
i j : α
hi : i = j
⊢ F.map (pullback.fst (c.inj i) (c.inj j)).op (Pi.π (fun i => F.obj (op (X i))) i a) =
    F.map (pullback.snd (c.inj i) (c.inj j)).op (Pi.π (fun i => F.obj (op (X i))) j a)

case neg
C : Type u
inst✝³ : Category.{v, u} C
I : C
F : Cᵒᵖ ⥤ Type w
hF : IsSheafFor F (ofArrows Empty.elim fun a => instIsEmptyEmpty.elim a)
hI : IsInitial I
α : Type
X : α → C
c : Cofan X
hc : IsColimit c
inst✝² : (ofArrows X c.inj).hasPullbacks
inst✝¹ : HasInitial C
inst✝ : ∀ (i : α), Mono (c.inj i)
hd : Pairwise fun i j => IsPullback (initial.to (X i)) (initial.to (X j)) (c.inj i) (c.inj j)
a : Equalizer.Presieve.Arrows.FirstObj F X
i j : α
hi : ¬i = j
⊢ F.map (pullback.fst (c.inj i) (c.inj j)).op (Pi.π (fun i => F.obj (op (X i))) i a) =
    F.map (pullback.snd (c.inj i) (c.inj j)).op (Pi.π (fun i => F.obj (op (X i))) j a)
tactic: by_cases hi : i = j