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

tactic: rw [Equalizer.Presieve.Arrows.sheaf_condition, Limits.Types.type_equalizer_iff_unique]
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
⊢ IsSheafFor F (ofArrows 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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
⊢ ∀ (y : Equalizer.Presieve.Arrows.FirstObj F X),
    Equalizer.Presieve.Arrows.firstMap F X c.inj y = Equalizer.Presieve.Arrows.secondMap F X c.inj y →
      ∃! x, Equalizer.Presieve.Arrows.forkMap F X c.inj x = y

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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
⊢ ∀ (y : Equalizer.Presieve.Arrows.FirstObj F X),
    Equalizer.Presieve.Arrows.firstMap F X c.inj y = Equalizer.Presieve.Arrows.secondMap F X c.inj y →
      ∃! x, Equalizer.Presieve.Arrows.forkMap F X c.inj x = y
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
⊢ ∀ (y : Equalizer.Presieve.Arrows.FirstObj F X),
    Equalizer.Presieve.Arrows.firstMap F X c.inj y = Equalizer.Presieve.Arrows.secondMap F X c.inj y →
      ∃! x, Equalizer.Presieve.Arrows.forkMap F X c.inj x = y

tactic: have hi : IsIso (piComparison F (fun x ↦ op (X x))) := inferInstance
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
⊢ ∀ (y : Equalizer.Presieve.Arrows.FirstObj F X),
    Equalizer.Presieve.Arrows.firstMap F X c.inj y = Equalizer.Presieve.Arrows.secondMap F X c.inj y →
      ∃! x, Equalizer.Presieve.Arrows.forkMap F X c.inj x = y
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi : IsIso (piComparison F fun x => { unop := X x })
⊢ ∀ (y : Equalizer.Presieve.Arrows.FirstObj F X),
    Equalizer.Presieve.Arrows.firstMap F X c.inj y = Equalizer.Presieve.Arrows.secondMap F X c.inj y →
      ∃! x, Equalizer.Presieve.Arrows.forkMap F X c.inj x = y

tactic: rw [piComparison_fac (hc := hc), isIso_iff_bijective, Function.bijective_iff_existsUnique] at hi
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi : IsIso (piComparison F fun x => { unop := X x })
⊢ ∀ (y : Equalizer.Presieve.Arrows.FirstObj F X),
    Equalizer.Presieve.Arrows.firstMap F X c.inj y = Equalizer.Presieve.Arrows.secondMap F X c.inj y →
      ∃! x, Equalizer.Presieve.Arrows.forkMap F X c.inj x = y
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
⊢ ∀ (y : Equalizer.Presieve.Arrows.FirstObj F X),
    Equalizer.Presieve.Arrows.firstMap F X c.inj y = Equalizer.Presieve.Arrows.secondMap F X c.inj y →
      ∃! x, Equalizer.Presieve.Arrows.forkMap F X c.inj x = y

tactic: intro b _
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
⊢ ∀ (y : Equalizer.Presieve.Arrows.FirstObj F X),
    Equalizer.Presieve.Arrows.firstMap F X c.inj y = Equalizer.Presieve.Arrows.secondMap F X c.inj y →
      ∃! x, Equalizer.Presieve.Arrows.forkMap F X c.inj x = y
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
⊢ ∃! x, Equalizer.Presieve.Arrows.forkMap F X c.inj x = b

tactic: obtain ⟨t, ht₁, ht₂⟩ := hi b
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
⊢ ∃! x, Equalizer.Presieve.Arrows.forkMap F X c.inj x = b
state_after: case intro.intro
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
⊢ ∃! x, Equalizer.Presieve.Arrows.forkMap F X c.inj x = b

tactic: refine ⟨F.map ((opCoproductIsoProduct' hc (productIsProduct _)).inv) t, ht₁, fun y hy ↦ ?_⟩
state_before: case intro.intro
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
⊢ ∃! x, Equalizer.Presieve.Arrows.forkMap F X c.inj x = b
state_after: case intro.intro
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ y = F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv t

tactic: apply_fun F.map ((opCoproductIsoProduct' hc (productIsProduct _)).hom) using injective_of_mono _
state_before: case intro.intro
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ y = F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv t
state_after: case intro.intro
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom y =
    F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv t)

tactic: simp only [← FunctorToTypes.map_comp_apply, Iso.op, Category.assoc]
state_before: case intro.intro
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom y =
    F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv t)
state_after: case intro.intro
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom y =
    F.map
      ((opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom)
      t

tactic: rw [ht₂ (F.map ((opCoproductIsoProduct' hc (productIsProduct _)).hom) y) (by simp [← hy])]
state_before: case intro.intro
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom y =
    F.map
      ((opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom)
      t
state_after: case intro.intro
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ t =
    F.map
      ((opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom)
      t

tactic: change (𝟙 (F.obj (∏ᶜ fun x ↦ op (X x)))) t = _
state_before: case intro.intro
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ t =
    F.map
      ((opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom)
      t
state_after: case intro.intro
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ 𝟙 (F.obj (∏ᶜ fun x => { unop := X x })) t =
    F.map
      ((opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom)
      t

tactic: rw [← Functor.map_id]
state_before: case intro.intro
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ 𝟙 (F.obj (∏ᶜ fun x => { unop := X x })) t =
    F.map
      ((opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom)
      t
state_after: case intro.intro
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ F.map (𝟙 (∏ᶜ fun x => { unop := X x })) t =
    F.map
      ((opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom)
      t

tactic: refine congrFun ?_ t
state_before: case intro.intro
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ F.map (𝟙 (∏ᶜ fun x => { unop := X x })) t =
    F.map
      ((opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom)
      t
state_after: case intro.intro
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ F.map (𝟙 (∏ᶜ fun x => { unop := X x })) =
    F.map
      ((opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom)

tactic: congr
state_before: case intro.intro
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ F.map (𝟙 (∏ᶜ fun x => { unop := X x })) =
    F.map
      ((opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom)
state_after: case intro.intro.e_a
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ 𝟙 (∏ᶜ fun x => { unop := X x }) =
    (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
      (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom

tactic: simp [Iso.eq_inv_comp, ← Category.assoc, ← op_comp, eq_comm, ← Iso.eq_comp_inv]
state_before: case intro.intro.e_a
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ 𝟙 (∏ᶜ fun x => { unop := X x }) =
    (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
      (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom
state_after: no goals

tactic: simp [← hy]
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)
inst✝ : PreservesLimit (Discrete.functor fun x => { unop := X x }) F
this : HasCoproduct X
hi :
  ∀ (b : ∏ᶜ fun b => F.obj { unop := X b }),
    ∃! a,
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b
b : Equalizer.Presieve.Arrows.FirstObj F X
a✝ : Equalizer.Presieve.Arrows.firstMap F X c.inj b = Equalizer.Presieve.Arrows.secondMap F X c.inj b
t : F.obj (∏ᶜ fun x => { unop := X x })
ht₁ :
  (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
        Equalizer.Presieve.Arrows.forkMap F X c.inj)
      t =
    b
ht₂ :
  ∀ (y : F.obj (∏ᶜ fun x => { unop := X x })),
    (fun a =>
          (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
                Equalizer.Presieve.Arrows.forkMap F X c.inj)
              a =
            b)
        y →
      y = t
y : F.obj { unop := c.pt }
hy : (fun x => Equalizer.Presieve.Arrows.forkMap F X c.inj x = b) y
⊢ (fun a =>
      (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).inv ≫
            Equalizer.Presieve.Arrows.forkMap F X c.inj)
          a =
        b)
    (F.map (opCoproductIsoProduct' hc (productIsProduct fun x => { unop := X x })).hom y)
state_after: no goals