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

tactic: have : HasCoproduct X := ⟨⟨c, hc⟩⟩
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)
⊢ let_fun this := ⋯;
  (piComparison F fun x => { unop := X x }) =
    F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
      Equalizer.Presieve.Arrows.forkMap F X c.inj
state_after: 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)
this : HasCoproduct X
⊢ let_fun this := ⋯;
  (piComparison F fun x => { unop := X x }) =
    F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
      Equalizer.Presieve.Arrows.forkMap F X c.inj

tactic: dsimp only [Equalizer.Presieve.Arrows.forkMap]
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)
this : HasCoproduct X
⊢ let_fun this := ⋯;
  (piComparison F fun x => { unop := X x }) =
    F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
      Equalizer.Presieve.Arrows.forkMap F X c.inj
state_after: 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)
this : HasCoproduct X
⊢ (piComparison F fun x => { unop := X x }) =
    F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
      Pi.lift fun i => F.map (c.inj i).op

tactic: have h : Pi.lift (fun i ↦ F.map (c.inj i).op) =
    F.map (Pi.lift (fun i ↦ (c.inj i).op)) ≫ piComparison F _ := by simp
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)
this : HasCoproduct X
⊢ (piComparison F fun x => { unop := X x }) =
    F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
      Pi.lift fun i => F.map (c.inj i).op
state_after: 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)
this : HasCoproduct X
h :
  (Pi.lift fun i => F.map (c.inj i).op) =
    F.map (Pi.lift fun i => (c.inj i).op) ≫ piComparison F fun i => { unop := X i }
⊢ (piComparison F fun x => { unop := X x }) =
    F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
      Pi.lift fun i => F.map (c.inj i).op

tactic: rw [h, ← Category.assoc, ← Functor.map_comp]
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)
this : HasCoproduct X
h :
  (Pi.lift fun i => F.map (c.inj i).op) =
    F.map (Pi.lift fun i => (c.inj i).op) ≫ piComparison F fun i => { unop := X i }
⊢ (piComparison F fun x => { unop := X x }) =
    F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
      Pi.lift fun i => F.map (c.inj i).op
state_after: 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)
this : HasCoproduct X
h :
  (Pi.lift fun i => F.map (c.inj i).op) =
    F.map (Pi.lift fun i => (c.inj i).op) ≫ piComparison F fun i => { unop := X i }
⊢ (piComparison F fun x => { unop := X x }) =
    F.map
        ((opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫ Pi.lift fun i => (c.inj i).op) ≫
      piComparison F fun i => { unop := X i }

tactic: rw [hh, ← desc_op_comp_opCoproductIsoProduct'_hom hc]
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)
this : HasCoproduct X
h :
  (Pi.lift fun i => F.map (c.inj i).op) =
    F.map (Pi.lift fun i => (c.inj i).op) ≫ piComparison F fun i => { unop := X i }
hh : (Pi.lift fun i => (c.inj i).op) = (productIsProduct fun x => { unop := X x }).lift c.op
⊢ (piComparison F fun x => { unop := X x }) =
    F.map
        ((opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫ Pi.lift fun i => (c.inj i).op) ≫
      piComparison F fun i => { unop := X i }
state_after: 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)
this : HasCoproduct X
h :
  (Pi.lift fun i => F.map (c.inj i).op) =
    F.map (Pi.lift fun i => (c.inj i).op) ≫ piComparison F fun i => { unop := X i }
hh : (Pi.lift fun i => (c.inj i).op) = (productIsProduct fun x => { unop := X x }).lift c.op
⊢ (piComparison F fun x => { unop := X x }) =
    F.map
        ((opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
          (hc.desc c).op ≫ (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom) ≫
      piComparison F fun i => { unop := X i }

tactic: simp
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)
this : HasCoproduct X
h :
  (Pi.lift fun i => F.map (c.inj i).op) =
    F.map (Pi.lift fun i => (c.inj i).op) ≫ piComparison F fun i => { unop := X i }
hh : (Pi.lift fun i => (c.inj i).op) = (productIsProduct fun x => { unop := X x }).lift c.op
⊢ (piComparison F fun x => { unop := X x }) =
    F.map
        ((opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
          (hc.desc c).op ≫ (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom) ≫
      piComparison F fun i => { unop := X i }
state_after: no goals

tactic: simp
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)
this : HasCoproduct X
⊢ (Pi.lift fun i => F.map (c.inj i).op) =
    F.map (Pi.lift fun i => (c.inj i).op) ≫ piComparison F fun i => { unop := X i }
state_after: no goals

tactic: simp [Pi.lift, productIsProduct]
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)
this : HasCoproduct X
h :
  (Pi.lift fun i => F.map (c.inj i).op) =
    F.map (Pi.lift fun i => (c.inj i).op) ≫ piComparison F fun i => { unop := X i }
⊢ (Pi.lift fun i => (c.inj i).op) = (productIsProduct fun x => { unop := X x }).lift c.op
state_after: no goals