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

tactic: ext a ⟨i, j⟩
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 { unop := 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 { unop := pullback (c.inj ij.1) (c.inj ij.2) }) (i, j)
      (Equalizer.Presieve.Arrows.secondMap F X c.inj 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 : α
⊢ Pi.π (fun ij => F.obj { unop := 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 { unop := 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.op (Pi.π (fun i => F.obj { unop := X i }) i a) =
    F.map pullback.snd.op (Pi.π (fun i => F.obj { unop := X i }) j a)

tactic: by_cases hi : 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 : α
⊢ F.map pullback.fst.op (Pi.π (fun i => F.obj { unop := X i }) i a) =
    F.map pullback.snd.op (Pi.π (fun i => F.obj { unop := 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.op (Pi.π (fun i => F.obj { unop := X i }) i a) =
    F.map pullback.snd.op (Pi.π (fun i => F.obj { unop := 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.op (Pi.π (fun i => F.obj { unop := X i }) i a) =
    F.map pullback.snd.op (Pi.π (fun i => F.obj { unop := X i }) j a)

tactic: rw [hi, Mono.right_cancellation _ _ pullback.condition]
state_before: 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.op (Pi.π (fun i => F.obj { unop := X i }) i a) =
    F.map pullback.snd.op (Pi.π (fun i => F.obj { unop := X i }) j a)
state_after: no goals

tactic: have := preservesTerminalOfIsSheafForEmpty F hF hI
state_before: 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.op (Pi.π (fun i => F.obj { unop := X i }) i a) =
    F.map pullback.snd.op (Pi.π (fun i => F.obj { unop := X i }) j a)
state_after: 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
this : PreservesLimit (Functor.empty Cᵒᵖ) F
⊢ F.map pullback.fst.op (Pi.π (fun i => F.obj { unop := X i }) i a) =
    F.map pullback.snd.op (Pi.π (fun i => F.obj { unop := X i }) j a)

tactic: apply_fun (F.mapIso ((hd hi).isoPullback).op ≪≫ F.mapIso (terminalIsoIsTerminal
  (terminalOpOfInitial initialIsInitial)).symm ≪≫ (PreservesTerminal.iso F)).hom using
  injective_of_mono _
state_before: 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
this : PreservesLimit (Functor.empty Cᵒᵖ) F
⊢ F.map pullback.fst.op (Pi.π (fun i => F.obj { unop := X i }) i a) =
    F.map pullback.snd.op (Pi.π (fun i => F.obj { unop := X i }) j a)
state_after: 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
this : PreservesLimit (Functor.empty Cᵒᵖ) F
⊢ (F.mapIso (IsPullback.isoPullback ⋯).op ≪≫
          F.mapIso (terminalIsoIsTerminal (terminalOpOfInitial initialIsInitial)).symm ≪≫ PreservesTerminal.iso F).hom
      (F.map pullback.fst.op (Pi.π (fun i => F.obj { unop := X i }) i a)) =
    (F.mapIso (IsPullback.isoPullback ⋯).op ≪≫
          F.mapIso (terminalIsoIsTerminal (terminalOpOfInitial initialIsInitial)).symm ≪≫ PreservesTerminal.iso F).hom
      (F.map pullback.snd.op (Pi.π (fun i => F.obj { unop := X i }) j a))

tactic: ext ⟨i⟩
state_before: 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
this : PreservesLimit (Functor.empty Cᵒᵖ) F
⊢ (F.mapIso (IsPullback.isoPullback ⋯).op ≪≫
          F.mapIso (terminalIsoIsTerminal (terminalOpOfInitial initialIsInitial)).symm ≪≫ PreservesTerminal.iso F).hom
      (F.map pullback.fst.op (Pi.π (fun i => F.obj { unop := X i }) i a)) =
    (F.mapIso (IsPullback.isoPullback ⋯).op ≪≫
          F.mapIso (terminalIsoIsTerminal (terminalOpOfInitial initialIsInitial)).symm ≪≫ PreservesTerminal.iso F).hom
      (F.map pullback.snd.op (Pi.π (fun i => F.obj { unop := X i }) j a))
state_after: case neg.w.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 : α
hi : ¬i✝ = j
this : PreservesLimit (Functor.empty Cᵒᵖ) F
i : PEmpty.{1}
⊢ limit.π (Functor.empty (Type w)) { as := i }
      ((F.mapIso (IsPullback.isoPullback ⋯).op ≪≫
            F.mapIso (terminalIsoIsTerminal (terminalOpOfInitial initialIsInitial)).symm ≪≫ PreservesTerminal.iso F).hom
        (F.map pullback.fst.op (Pi.π (fun i => F.obj { unop := X i }) i✝ a))) =
    limit.π (Functor.empty (Type w)) { as := i }
      ((F.mapIso (IsPullback.isoPullback ⋯).op ≪≫
            F.mapIso (terminalIsoIsTerminal (terminalOpOfInitial initialIsInitial)).symm ≪≫ PreservesTerminal.iso F).hom
        (F.map pullback.snd.op (Pi.π (fun i => F.obj { unop := X i }) j a)))

tactic: exact i.elim
state_before: case neg.w.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 : α
hi : ¬i✝ = j
this : PreservesLimit (Functor.empty Cᵒᵖ) F
i : PEmpty.{1}
⊢ limit.π (Functor.empty (Type w)) { as := i }
      ((F.mapIso (IsPullback.isoPullback ⋯).op ≪≫
            F.mapIso (terminalIsoIsTerminal (terminalOpOfInitial initialIsInitial)).symm ≪≫ PreservesTerminal.iso F).hom
        (F.map pullback.fst.op (Pi.π (fun i => F.obj { unop := X i }) i✝ a))) =
    limit.π (Functor.empty (Type w)) { as := i }
      ((F.mapIso (IsPullback.isoPullback ⋯).op ≪≫
            F.mapIso (terminalIsoIsTerminal (terminalOpOfInitial initialIsInitial)).symm ≪≫ PreservesTerminal.iso F).hom
        (F.map pullback.snd.op (Pi.π (fun i => F.obj { unop := X i }) j a)))
state_after: no goals