Theorem: CategoryTheory.GrothendieckTopology.plusMap_toPlus
File: Mathlib/CategoryTheory/Sites/Plus.lean

tactic: ext X : 2
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
⊢ plusMap J (toPlus J P) = toPlus J (plusObj J P)

tactic: refine' colimit.hom_ext (fun S => _)
state_before: case w.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
⊢ (plusMap J (toPlus J P)).app X = (toPlus J (plusObj J P)).app X

tactic: dsimp only [plusMap, toPlus]
state_before: case w.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
⊢ colimit.ι (diagram J P X.unop) S ≫ (plusMap J (toPlus J P)).app X =
    colimit.ι (diagram J P X.unop) S ≫ (toPlus J (plusObj J P)).app X

tactic: let e : S.unop ⟶ ⊤ := homOfLE (OrderTop.le_top _)
state_before: case w.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
⊢ colimit.ι (diagram J P X.unop) S ≫
      colimMap
        (diagramNatTrans J (NatTrans.mk fun X => Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P X.unop) ⊤.op)
          X.unop) =
    colimit.ι (diagram J P X.unop) S ≫
      Cover.toMultiequalizer ⊤ (plusObj J P) ≫ colimit.ι (diagram J (plusObj J P) X.unop) ⊤.op

tactic: rw [ι_colimMap, ← colimit.w _ e.op, ← Category.assoc, ← Category.assoc]
state_before: case w.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
⊢ colimit.ι (diagram J P X.unop) S ≫
      colimMap
        (diagramNatTrans J (NatTrans.mk fun X => Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P X.unop) ⊤.op)
          X.unop) =
    colimit.ι (diagram J P X.unop) S ≫
      Cover.toMultiequalizer ⊤ (plusObj J P) ≫ colimit.ι (diagram J (plusObj J P) X.unop) ⊤.op

tactic: congr 1
state_before: case w.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
⊢ (diagramNatTrans J (NatTrans.mk fun X => Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P X.unop) ⊤.op) X.unop).app
        S ≫
      colimit.ι (diagram J (plusObj J P) X.unop) S =
    ((colimit.ι (diagram J P X.unop) S ≫ Cover.toMultiequalizer ⊤ (plusObj J P)) ≫
        (diagram J (plusObj J P) X.unop).map e.op) ≫
      colimit.ι (diagram J (plusObj J P) X.unop) S.unop.op

tactic: refine' Multiequalizer.hom_ext _ _ _ (fun I => _)
state_before: case w.h.e_a
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
⊢ (diagramNatTrans J (NatTrans.mk fun X => Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P X.unop) ⊤.op) X.unop).app
      S =
    (colimit.ι (diagram J P X.unop) S ≫ Cover.toMultiequalizer ⊤ (plusObj J P)) ≫
      (diagram J (plusObj J P) X.unop).map e.op

tactic: erw [Multiequalizer.lift_ι]
state_before: case w.h.e_a
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
⊢ (diagramNatTrans J (NatTrans.mk fun X => Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P X.unop) ⊤.op) X.unop).app
        S ≫
      Multiequalizer.ι (Cover.index S.unop (plusObj J P)) I =
    ((colimit.ι (diagram J P X.unop) S ≫ Cover.toMultiequalizer ⊤ (plusObj J P)) ≫
        (diagram J (plusObj J P) X.unop).map e.op) ≫
      Multiequalizer.ι (Cover.index S.unop (plusObj J P)) I

tactic: simp only [unop_op, op_unop, diagram_map, Category.assoc, limit.lift_π,
  Multifork.ofι_π_app]
state_before: case w.h.e_a
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
⊢ Multiequalizer.ι (Cover.index S.unop P) I ≫
      (NatTrans.mk fun X => Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P X.unop) ⊤.op).app I.Y.op =
    ((colimit.ι (diagram J P X.unop) S ≫ Cover.toMultiequalizer ⊤ (plusObj J P)) ≫
        (diagram J (plusObj J P) X.unop).map e.op) ≫
      Multiequalizer.ι (Cover.index S.unop (plusObj J P)) I

tactic: let ee : (J.pullback (I.map e).f).obj S.unop ⟶ ⊤ := homOfLE (OrderTop.le_top _)
state_before: case w.h.e_a
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
⊢ Multiequalizer.ι (Cover.index S.unop P) I ≫ Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P I.Y) ⊤.op =
    colimit.ι (diagram J P X.unop) S ≫ (plusObj J P).map (Cover.Arrow.map I (homOfLE (_ : S.unop ≤ ⊤)).op.unop).f.op

tactic: erw [← colimit.w _ ee.op, ι_colimMap_assoc, colimit.ι_pre, diagramPullback_app,
  ← Category.assoc, ← Category.assoc]
state_before: case w.h.e_a
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
ee : (pullback J (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ :=
  homOfLE (_ : (pullback J (Cover.Arrow.map I e).f).obj S.unop ≤ ⊤)
⊢ Multiequalizer.ι (Cover.index S.unop P) I ≫ Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P I.Y) ⊤.op =
    colimit.ι (diagram J P X.unop) S ≫ (plusObj J P).map (Cover.Arrow.map I (homOfLE (_ : S.unop ≤ ⊤)).op.unop).f.op

tactic: congr 1
state_before: case w.h.e_a
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
ee : (pullback J (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ :=
  homOfLE (_ : (pullback J (Cover.Arrow.map I e).f).obj S.unop ≤ ⊤)
⊢ ((Multiequalizer.ι (Cover.index S.unop P) I ≫ Cover.toMultiequalizer ⊤ P) ≫ (diagram J P I.Y).map ee.op) ≫
      colimit.ι (diagram J P I.Y) ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op =
    Multiequalizer.lift
        (Cover.index
          ((Functor.op (pullback J (Cover.Arrow.map I (homOfLE (_ : S.unop ≤ ⊤)).op.unop).f.op.unop)).obj S).unop P)
        ((diagram J P X.unop).obj S) (fun I_1 => Multiequalizer.ι (Cover.index S.unop P) (Cover.Arrow.base I_1))
        (_ :
          ∀
            (I_1 :
              (Cover.index
                  ((Functor.op (pullback J (Cover.Arrow.map I (homOfLE (_ : S.unop ≤ ⊤)).op.unop).f.op.unop)).obj
                      S).unop
                  P).R),
            Multiequalizer.ι (Cover.index S.unop P)
                  (MulticospanIndex.fstTo (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
                MulticospanIndex.fst (Cover.index S.unop P) (Cover.Relation.base I_1) =
              Multiequalizer.ι (Cover.index S.unop P)
                  (MulticospanIndex.sndTo (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
                MulticospanIndex.snd (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
      colimit.ι (diagram J P (Cover.Arrow.map I (homOfLE (_ : S.unop ≤ ⊤)).op.unop).Y.op.unop)
        ((Functor.op (pullback J (Cover.Arrow.map I (homOfLE (_ : S.unop ≤ ⊤)).op.unop).f.op.unop)).obj S)

tactic: refine' Multiequalizer.hom_ext _ _ _ (fun II => _)
state_before: case w.h.e_a.e_a
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
ee : (pullback J (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ :=
  homOfLE (_ : (pullback J (Cover.Arrow.map I e).f).obj S.unop ≤ ⊤)
⊢ (Multiequalizer.ι (Cover.index S.unop P) I ≫ Cover.toMultiequalizer ⊤ P) ≫ (diagram J P I.Y).map ee.op =
    Multiequalizer.lift
      (Cover.index
        ((Functor.op (pullback J (Cover.Arrow.map I (homOfLE (_ : S.unop ≤ ⊤)).op.unop).f.op.unop)).obj S).unop P)
      ((diagram J P X.unop).obj S) (fun I_1 => Multiequalizer.ι (Cover.index S.unop P) (Cover.Arrow.base I_1))
      (_ :
        ∀
          (I_1 :
            (Cover.index
                ((Functor.op (pullback J (Cover.Arrow.map I (homOfLE (_ : S.unop ≤ ⊤)).op.unop).f.op.unop)).obj S).unop
                P).R),
          Multiequalizer.ι (Cover.index S.unop P)
                (MulticospanIndex.fstTo (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
              MulticospanIndex.fst (Cover.index S.unop P) (Cover.Relation.base I_1) =
            Multiequalizer.ι (Cover.index S.unop P)
                (MulticospanIndex.sndTo (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
              MulticospanIndex.snd (Cover.index S.unop P) (Cover.Relation.base I_1))

tactic: convert (Multiequalizer.condition (S.unop.index P)
    ⟨_, _, _, II.f, 𝟙 _, I.f, II.f ≫ I.f, I.hf,
      Sieve.downward_closed _ I.hf _, by simp⟩) using 1
state_before: case w.h.e_a.e_a
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
ee : (pullback J (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ :=
  homOfLE (_ : (pullback J (Cover.Arrow.map I e).f).obj S.unop ≤ ⊤)
II : (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P).L
⊢ ((Multiequalizer.ι (Cover.index S.unop P) I ≫ Cover.toMultiequalizer ⊤ P) ≫ (diagram J P I.Y).map ee.op) ≫
      Multiequalizer.ι (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P) II =
    Multiequalizer.lift
        (Cover.index
          ((Functor.op (pullback J (Cover.Arrow.map I (homOfLE (_ : S.unop ≤ ⊤)).op.unop).f.op.unop)).obj S).unop P)
        ((diagram J P X.unop).obj S) (fun I_1 => Multiequalizer.ι (Cover.index S.unop P) (Cover.Arrow.base I_1))
        (_ :
          ∀
            (I_1 :
              (Cover.index
                  ((Functor.op (pullback J (Cover.Arrow.map I (homOfLE (_ : S.unop ≤ ⊤)).op.unop).f.op.unop)).obj
                      S).unop
                  P).R),
            Multiequalizer.ι (Cover.index S.unop P)
                  (MulticospanIndex.fstTo (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
                MulticospanIndex.fst (Cover.index S.unop P) (Cover.Relation.base I_1) =
              Multiequalizer.ι (Cover.index S.unop P)
                  (MulticospanIndex.sndTo (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
                MulticospanIndex.snd (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
      Multiequalizer.ι (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P) II

tactic: . dsimp [diagram]
  cases I
  simp only [Category.assoc, limit.lift_π, Multifork.ofι_pt, Multifork.ofι_π_app,
    Cover.Arrow.map_Y, Cover.Arrow.map_f]
  rfl
state_before: case h.e'_2.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
ee : (pullback J (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ :=
  homOfLE (_ : (pullback J (Cover.Arrow.map I e).f).obj S.unop ≤ ⊤)
II : (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P).L
e_1✝ :
  ((diagram J P X.unop).obj S ⟶
      MulticospanIndex.left (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P) II) =
    (multiequalizer (Cover.index S.unop P) ⟶
      MulticospanIndex.right (Cover.index S.unop P)
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) })
⊢ ((Multiequalizer.ι (Cover.index S.unop P) I ≫ Cover.toMultiequalizer ⊤ P) ≫ (diagram J P I.Y).map ee.op) ≫
      Multiequalizer.ι (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P) II =
    Multiequalizer.ι (Cover.index S.unop P)
        (MulticospanIndex.fstTo (Cover.index S.unop P)
          { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
            h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
            w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) }) ≫
      MulticospanIndex.fst (Cover.index S.unop P)
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) }

case h.e'_3.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
ee : (pullback J (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ :=
  homOfLE (_ : (pullback J (Cover.Arrow.map I e).f).obj S.unop ≤ ⊤)
II : (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P).L
e_1✝ :
  ((diagram J P X.unop).obj S ⟶
      MulticospanIndex.left (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P) II) =
    (multiequalizer (Cover.index S.unop P) ⟶
      MulticospanIndex.right (Cover.index S.unop P)
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) })
⊢ Multiequalizer.lift
        (Cover.index
          ((Functor.op (pullback J (Cover.Arrow.map I (homOfLE (_ : S.unop ≤ ⊤)).op.unop).f.op.unop)).obj S).unop P)
        ((diagram J P X.unop).obj S) (fun I_1 => Multiequalizer.ι (Cover.index S.unop P) (Cover.Arrow.base I_1))
        (_ :
          ∀
            (I_1 :
              (Cover.index
                  ((Functor.op (pullback J (Cover.Arrow.map I (homOfLE (_ : S.unop ≤ ⊤)).op.unop).f.op.unop)).obj
                      S).unop
                  P).R),
            Multiequalizer.ι (Cover.index S.unop P)
                  (MulticospanIndex.fstTo (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
                MulticospanIndex.fst (Cover.index S.unop P) (Cover.Relation.base I_1) =
              Multiequalizer.ι (Cover.index S.unop P)
                  (MulticospanIndex.sndTo (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
                MulticospanIndex.snd (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
      Multiequalizer.ι (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P) II =
    Multiequalizer.ι (Cover.index S.unop P)
        (MulticospanIndex.sndTo (Cover.index S.unop P)
          { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
            h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
            w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) }) ≫
      MulticospanIndex.snd (Cover.index S.unop P)
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) }

tactic: . erw [Multiequalizer.lift_ι]
  dsimp [Cover.index]
  simp only [Functor.map_id, Category.comp_id]
  rfl
state_before: case h.e'_3.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
ee : (pullback J (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ :=
  homOfLE (_ : (pullback J (Cover.Arrow.map I e).f).obj S.unop ≤ ⊤)
II : (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P).L
e_1✝ :
  ((diagram J P X.unop).obj S ⟶
      MulticospanIndex.left (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P) II) =
    (multiequalizer (Cover.index S.unop P) ⟶
      MulticospanIndex.right (Cover.index S.unop P)
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) })
⊢ Multiequalizer.lift
        (Cover.index
          ((Functor.op (pullback J (Cover.Arrow.map I (homOfLE (_ : S.unop ≤ ⊤)).op.unop).f.op.unop)).obj S).unop P)
        ((diagram J P X.unop).obj S) (fun I_1 => Multiequalizer.ι (Cover.index S.unop P) (Cover.Arrow.base I_1))
        (_ :
          ∀
            (I_1 :
              (Cover.index
                  ((Functor.op (pullback J (Cover.Arrow.map I (homOfLE (_ : S.unop ≤ ⊤)).op.unop).f.op.unop)).obj
                      S).unop
                  P).R),
            Multiequalizer.ι (Cover.index S.unop P)
                  (MulticospanIndex.fstTo (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
                MulticospanIndex.fst (Cover.index S.unop P) (Cover.Relation.base I_1) =
              Multiequalizer.ι (Cover.index S.unop P)
                  (MulticospanIndex.sndTo (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
                MulticospanIndex.snd (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
      Multiequalizer.ι (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P) II =
    Multiequalizer.ι (Cover.index S.unop P)
        (MulticospanIndex.sndTo (Cover.index S.unop P)
          { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
            h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
            w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) }) ≫
      MulticospanIndex.snd (Cover.index S.unop P)
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) }

tactic: simp
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
ee : (pullback J (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ :=
  homOfLE (_ : (pullback J (Cover.Arrow.map I e).f).obj S.unop ≤ ⊤)
II : (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P).L
⊢ II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f

tactic: dsimp [diagram]
state_before: case h.e'_2.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
ee : (pullback J (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ :=
  homOfLE (_ : (pullback J (Cover.Arrow.map I e).f).obj S.unop ≤ ⊤)
II : (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P).L
e_1✝ :
  ((diagram J P X.unop).obj S ⟶
      MulticospanIndex.left (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P) II) =
    (multiequalizer (Cover.index S.unop P) ⟶
      MulticospanIndex.right (Cover.index S.unop P)
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) })
⊢ ((Multiequalizer.ι (Cover.index S.unop P) I ≫ Cover.toMultiequalizer ⊤ P) ≫ (diagram J P I.Y).map ee.op) ≫
      Multiequalizer.ι (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P) II =
    Multiequalizer.ι (Cover.index S.unop P)
        (MulticospanIndex.fstTo (Cover.index S.unop P)
          { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
            h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
            w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) }) ≫
      MulticospanIndex.fst (Cover.index S.unop P)
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) }

tactic: cases I
state_before: case h.e'_2.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
ee : (pullback J (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ :=
  homOfLE (_ : (pullback J (Cover.Arrow.map I e).f).obj S.unop ≤ ⊤)
II : (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P).L
e_1✝ :
  ((diagram J P X.unop).obj S ⟶
      MulticospanIndex.left (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P) II) =
    (multiequalizer (Cover.index S.unop P) ⟶
      MulticospanIndex.right (Cover.index S.unop P)
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) })
⊢ ((Multiequalizer.ι (Cover.index S.unop P) I ≫ Cover.toMultiequalizer ⊤ P) ≫
        Multiequalizer.lift (Cover.index (Cover.pullback S.unop I.f) P) (multiequalizer (Cover.index ⊤ P))
          (fun I_1 =>
            Multiequalizer.ι (Cover.index ⊤ P) (Cover.Arrow.map I_1 (homOfLE (_ : Cover.pullback S.unop I.f ≤ ⊤))))
          (_ :
            ∀ (I_1 : (Cover.index (Cover.pullback S.unop I.f).op.unop P).R),
              Multiequalizer.ι (Cover.index ⊤.op.unop P)
                    (MulticospanIndex.fstTo (Cover.index ⊤.op.unop P)
                      (Cover.Relation.map I_1 (homOfLE (_ : Cover.pullback S.unop I.f ≤ ⊤)).op.unop)) ≫
                  MulticospanIndex.fst (Cover.index ⊤.op.unop P)
                    (Cover.Relation.map I_1 (homOfLE (_ : Cover.pullback S.unop I.f ≤ ⊤)).op.unop) =
                Multiequalizer.ι (Cover.index ⊤.op.unop P)
                    (MulticospanIndex.sndTo (Cover.index ⊤.op.unop P)
                      (Cover.Relation.map I_1 (homOfLE (_ : Cover.pullback S.unop I.f ≤ ⊤)).op.unop)) ≫
                  MulticospanIndex.snd (Cover.index ⊤.op.unop P)
                    (Cover.Relation.map I_1 (homOfLE (_ : Cover.pullback S.unop I.f ≤ ⊤)).op.unop))) ≫
      Multiequalizer.ι (Cover.index (Cover.pullback S.unop I.f) P) II =
    Multiequalizer.ι (Cover.index S.unop P)
        (MulticospanIndex.fstTo (Cover.index S.unop P)
          { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
            h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
            w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) }) ≫
      MulticospanIndex.fst (Cover.index S.unop P)
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) }

tactic: simp only [Category.assoc, limit.lift_π, Multifork.ofι_pt, Multifork.ofι_π_app,
  Cover.Arrow.map_Y, Cover.Arrow.map_f]
state_before: case h.e'_2.h.mk
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
Y✝ : C
f✝ : Y✝ ⟶ X.unop
hf✝ : (Cover.sieve S.unop).arrows f✝
ee : (pullback J (Cover.Arrow.map { Y := Y✝, f := f✝, hf := hf✝ } e).f).obj S.unop ⟶ ⊤ :=
  homOfLE (_ : (pullback J (Cover.Arrow.map { Y := Y✝, f := f✝, hf := hf✝ } e).f).obj S.unop ≤ ⊤)
II : (Cover.index ((pullback J (Cover.Arrow.map { Y := Y✝, f := f✝, hf := hf✝ } e).f).obj S.unop).op.unop P).L
e_1✝ :
  ((diagram J P X.unop).obj S ⟶
      MulticospanIndex.left
        (Cover.index ((pullback J (Cover.Arrow.map { Y := Y✝, f := f✝, hf := hf✝ } e).f).obj S.unop).op.unop P) II) =
    (multiequalizer (Cover.index S.unop P) ⟶
      MulticospanIndex.right (Cover.index S.unop P)
        { Y₁ := { Y := Y✝, f := f✝, hf := hf✝ }.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y,
          f₁ := { Y := Y✝, f := f✝, hf := hf✝ }.f, f₂ := II.f ≫ { Y := Y✝, f := f✝, hf := hf✝ }.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows { Y := Y✝, f := f✝, hf := hf✝ }.f),
          h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ { Y := Y✝, f := f✝, hf := hf✝ }.f)),
          w := (_ : II.f ≫ { Y := Y✝, f := f✝, hf := hf✝ }.f = 𝟙 II.Y ≫ II.f ≫ { Y := Y✝, f := f✝, hf := hf✝ }.f) })
⊢ ((Multiequalizer.ι (Cover.index S.unop P) { Y := Y✝, f := f✝, hf := hf✝ } ≫ Cover.toMultiequalizer ⊤ P) ≫
        Multiequalizer.lift (Cover.index (Cover.pullback S.unop { Y := Y✝, f := f✝, hf := hf✝ }.f) P)
          (multiequalizer (Cover.index ⊤ P))
          (fun I =>
            Multiequalizer.ι (Cover.index ⊤ P)
              (Cover.Arrow.map I (homOfLE (_ : Cover.pullback S.unop { Y := Y✝, f := f✝, hf := hf✝ }.f ≤ ⊤))))
          (_ :
            ∀ (I : (Cover.index (Cover.pullback S.unop { Y := Y✝, f := f✝, hf := hf✝ }.f).op.unop P).R),
              Multiequalizer.ι (Cover.index ⊤.op.unop P)
                    (MulticospanIndex.fstTo (Cover.index ⊤.op.unop P)
                      (Cover.Relation.map I
                        (homOfLE (_ : Cover.pullback S.unop { Y := Y✝, f := f✝, hf := hf✝ }.f ≤ ⊤)).op.unop)) ≫
                  MulticospanIndex.fst (Cover.index ⊤.op.unop P)
                    (Cover.Relation.map I
                      (homOfLE (_ : Cover.pullback S.unop { Y := Y✝, f := f✝, hf := hf✝ }.f ≤ ⊤)).op.unop) =
                Multiequalizer.ι (Cover.index ⊤.op.unop P)
                    (MulticospanIndex.sndTo (Cover.index ⊤.op.unop P)
                      (Cover.Relation.map I
                        (homOfLE (_ : Cover.pullback S.unop { Y := Y✝, f := f✝, hf := hf✝ }.f ≤ ⊤)).op.unop)) ≫
                  MulticospanIndex.snd (Cover.index ⊤.op.unop P)
                    (Cover.Relation.map I
                      (homOfLE (_ : Cover.pullback S.unop { Y := Y✝, f := f✝, hf := hf✝ }.f ≤ ⊤)).op.unop))) ≫
      Multiequalizer.ι (Cover.index (Cover.pullback S.unop { Y := Y✝, f := f✝, hf := hf✝ }.f) P) II =
    Multiequalizer.ι (Cover.index S.unop P)
        (MulticospanIndex.fstTo (Cover.index S.unop P)
          { Y₁ := { Y := Y✝, f := f✝, hf := hf✝ }.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y,
            f₁ := { Y := Y✝, f := f✝, hf := hf✝ }.f, f₂ := II.f ≫ { Y := Y✝, f := f✝, hf := hf✝ }.f,
            h₁ := (_ : (Cover.sieve S.unop).arrows { Y := Y✝, f := f✝, hf := hf✝ }.f),
            h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ { Y := Y✝, f := f✝, hf := hf✝ }.f)),
            w := (_ : II.f ≫ { Y := Y✝, f := f✝, hf := hf✝ }.f = 𝟙 II.Y ≫ II.f ≫ { Y := Y✝, f := f✝, hf := hf✝ }.f) }) ≫
      MulticospanIndex.fst (Cover.index S.unop P)
        { Y₁ := { Y := Y✝, f := f✝, hf := hf✝ }.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y,
          f₁ := { Y := Y✝, f := f✝, hf := hf✝ }.f, f₂ := II.f ≫ { Y := Y✝, f := f✝, hf := hf✝ }.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows { Y := Y✝, f := f✝, hf := hf✝ }.f),
          h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ { Y := Y✝, f := f✝, hf := hf✝ }.f)),
          w := (_ : II.f ≫ { Y := Y✝, f := f✝, hf := hf✝ }.f = 𝟙 II.Y ≫ II.f ≫ { Y := Y✝, f := f✝, hf := hf✝ }.f) }

tactic: rfl
state_before: case h.e'_2.h.mk
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
Y✝ : C
f✝ : Y✝ ⟶ X.unop
hf✝ : (Cover.sieve S.unop).arrows f✝
ee : (pullback J (Cover.Arrow.map { Y := Y✝, f := f✝, hf := hf✝ } e).f).obj S.unop ⟶ ⊤ :=
  homOfLE (_ : (pullback J (Cover.Arrow.map { Y := Y✝, f := f✝, hf := hf✝ } e).f).obj S.unop ≤ ⊤)
II : (Cover.index ((pullback J (Cover.Arrow.map { Y := Y✝, f := f✝, hf := hf✝ } e).f).obj S.unop).op.unop P).L
e_1✝ :
  ((diagram J P X.unop).obj S ⟶
      MulticospanIndex.left
        (Cover.index ((pullback J (Cover.Arrow.map { Y := Y✝, f := f✝, hf := hf✝ } e).f).obj S.unop).op.unop P) II) =
    (multiequalizer (Cover.index S.unop P) ⟶
      MulticospanIndex.right (Cover.index S.unop P)
        { Y₁ := { Y := Y✝, f := f✝, hf := hf✝ }.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y,
          f₁ := { Y := Y✝, f := f✝, hf := hf✝ }.f, f₂ := II.f ≫ { Y := Y✝, f := f✝, hf := hf✝ }.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows { Y := Y✝, f := f✝, hf := hf✝ }.f),
          h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ { Y := Y✝, f := f✝, hf := hf✝ }.f)),
          w := (_ : II.f ≫ { Y := Y✝, f := f✝, hf := hf✝ }.f = 𝟙 II.Y ≫ II.f ≫ { Y := Y✝, f := f✝, hf := hf✝ }.f) })
⊢ Multiequalizer.ι (Cover.index S.unop P) { Y := Y✝, f := f✝, hf := hf✝ } ≫ P.map II.f.op =
    Multiequalizer.ι (Cover.index S.unop P)
        (MulticospanIndex.fstTo (Cover.index S.unop P)
          { Y₁ := Y✝, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := f✝, f₂ := II.f ≫ f✝, h₁ := hf✝,
            h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ f✝)), w := (_ : II.f ≫ f✝ = 𝟙 II.Y ≫ II.f ≫ f✝) }) ≫
      MulticospanIndex.fst (Cover.index S.unop P)
        { Y₁ := Y✝, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := f✝, f₂ := II.f ≫ f✝, h₁ := hf✝,
          h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ f✝)), w := (_ : II.f ≫ f✝ = 𝟙 II.Y ≫ II.f ≫ f✝) }

tactic: erw [Multiequalizer.lift_ι]
state_before: case h.e'_3.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
ee : (pullback J (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ :=
  homOfLE (_ : (pullback J (Cover.Arrow.map I e).f).obj S.unop ≤ ⊤)
II : (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P).L
e_1✝ :
  ((diagram J P X.unop).obj S ⟶
      MulticospanIndex.left (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P) II) =
    (multiequalizer (Cover.index S.unop P) ⟶
      MulticospanIndex.right (Cover.index S.unop P)
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) })
⊢ Multiequalizer.lift
        (Cover.index
          ((Functor.op (pullback J (Cover.Arrow.map I (homOfLE (_ : S.unop ≤ ⊤)).op.unop).f.op.unop)).obj S).unop P)
        ((diagram J P X.unop).obj S) (fun I_1 => Multiequalizer.ι (Cover.index S.unop P) (Cover.Arrow.base I_1))
        (_ :
          ∀
            (I_1 :
              (Cover.index
                  ((Functor.op (pullback J (Cover.Arrow.map I (homOfLE (_ : S.unop ≤ ⊤)).op.unop).f.op.unop)).obj
                      S).unop
                  P).R),
            Multiequalizer.ι (Cover.index S.unop P)
                  (MulticospanIndex.fstTo (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
                MulticospanIndex.fst (Cover.index S.unop P) (Cover.Relation.base I_1) =
              Multiequalizer.ι (Cover.index S.unop P)
                  (MulticospanIndex.sndTo (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
                MulticospanIndex.snd (Cover.index S.unop P) (Cover.Relation.base I_1)) ≫
      Multiequalizer.ι (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P) II =
    Multiequalizer.ι (Cover.index S.unop P)
        (MulticospanIndex.sndTo (Cover.index S.unop P)
          { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
            h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
            w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) }) ≫
      MulticospanIndex.snd (Cover.index S.unop P)
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) }

tactic: dsimp [Cover.index]
state_before: case h.e'_3.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
ee : (pullback J (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ :=
  homOfLE (_ : (pullback J (Cover.Arrow.map I e).f).obj S.unop ≤ ⊤)
II : (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P).L
e_1✝ :
  ((diagram J P X.unop).obj S ⟶
      MulticospanIndex.left (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P) II) =
    (multiequalizer (Cover.index S.unop P) ⟶
      MulticospanIndex.right (Cover.index S.unop P)
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) })
⊢ Multiequalizer.ι (Cover.index S.unop P) (Cover.Arrow.base II) =
    Multiequalizer.ι (Cover.index S.unop P)
        (MulticospanIndex.sndTo (Cover.index S.unop P)
          { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
            h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
            w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) }) ≫
      MulticospanIndex.snd (Cover.index S.unop P)
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) }

tactic: simp only [Functor.map_id, Category.comp_id]
state_before: case h.e'_3.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
ee : (pullback J (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ :=
  homOfLE (_ : (pullback J (Cover.Arrow.map I e).f).obj S.unop ≤ ⊤)
II : (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P).L
e_1✝ :
  ((diagram J P X.unop).obj S ⟶
      MulticospanIndex.left (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P) II) =
    (multiequalizer (Cover.index S.unop P) ⟶
      MulticospanIndex.right (Cover.index S.unop P)
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) })
⊢ Multiequalizer.ι
      { L := Cover.Arrow S.unop, R := Cover.Relation S.unop, fstTo := fun I => Cover.Relation.fst I,
        sndTo := fun I => Cover.Relation.snd I, left := fun I => P.obj I.Y.op, right := fun I => P.obj I.Z.op,
        fst := fun I => P.map I.g₁.op, snd := fun I => P.map I.g₂.op }
      (Cover.Arrow.base II) =
    Multiequalizer.ι
        { L := Cover.Arrow S.unop, R := Cover.Relation S.unop, fstTo := fun I => Cover.Relation.fst I,
          sndTo := fun I => Cover.Relation.snd I, left := fun I => P.obj I.Y.op, right := fun I => P.obj I.Z.op,
          fst := fun I => P.map I.g₁.op, snd := fun I => P.map I.g₂.op }
        (Cover.Relation.snd
          { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
            h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
            w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) }) ≫
      P.map (𝟙 II.Y.op)

tactic: rfl
state_before: case h.e'_3.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
X : Cᵒᵖ
S : (Cover J X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE (_ : S.unop ≤ ⊤)
I : (Cover.index S.unop (plusObj J P)).L
ee : (pullback J (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ :=
  homOfLE (_ : (pullback J (Cover.Arrow.map I e).f).obj S.unop ≤ ⊤)
II : (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P).L
e_1✝ :
  ((diagram J P X.unop).obj S ⟶
      MulticospanIndex.left (Cover.index ((pullback J (Cover.Arrow.map I e).f).obj S.unop).op.unop P) II) =
    (multiequalizer (Cover.index S.unop P) ⟶
      MulticospanIndex.right (Cover.index S.unop P)
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) })
⊢ Multiequalizer.ι
      { L := Cover.Arrow S.unop, R := Cover.Relation S.unop, fstTo := fun I => Cover.Relation.fst I,
        sndTo := fun I => Cover.Relation.snd I, left := fun I => P.obj I.Y.op, right := fun I => P.obj I.Z.op,
        fst := fun I => P.map I.g₁.op, snd := fun I => P.map I.g₂.op }
      (Cover.Arrow.base II) =
    Multiequalizer.ι
      { L := Cover.Arrow S.unop, R := Cover.Relation S.unop, fstTo := fun I => Cover.Relation.fst I,
        sndTo := fun I => Cover.Relation.snd I, left := fun I => P.obj I.Y.op, right := fun I => P.obj I.Z.op,
        fst := fun I => P.map I.g₁.op, snd := fun I => P.map I.g₂.op }
      (Cover.Relation.snd
        { Y₁ := I.Y, Y₂ := II.Y, Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, f₁ := I.f, f₂ := II.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S.unop).arrows I.f), h₂ := (_ : (Cover.sieve S.unop).arrows (II.f ≫ I.f)),
          w := (_ : II.f ≫ I.f = 𝟙 II.Y ≫ II.f ≫ I.f) })