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

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

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

tactic: dsimp only [plusMap, toPlus]
state_before: case w.h
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
X : Cᵒᵖ
S : (J.Cover X.unop)ᵒᵖ
⊢ colimit.ι (J.diagram P X.unop) S ≫ (J.plusMap (J.toPlus P)).app X =
    colimit.ι (J.diagram P X.unop) S ≫ (J.toPlus (J.plusObj P)).app X
state_after: case w.h
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
X : Cᵒᵖ
S : (J.Cover X.unop)ᵒᵖ
⊢ colimit.ι (J.diagram P X.unop) S ≫
      colimMap
        (J.diagramNatTrans
          { app := fun X => ⊤.toMultiequalizer P ≫ colimit.ι (J.diagram P X.unop) { unop := ⊤ }, naturality := ⋯ }
          X.unop) =
    colimit.ι (J.diagram P X.unop) S ≫
      ⊤.toMultiequalizer (J.plusObj P) ≫ colimit.ι (J.diagram (J.plusObj P) X.unop) { unop := ⊤ }

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

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

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

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

tactic: erw [Multiequalizer.lift_ι]
state_before: case w.h.e_a
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
X : Cᵒᵖ
S : (J.Cover X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE ⋯
I : (S.unop.index (J.plusObj P)).L
⊢ (J.diagramNatTrans
            { app := fun X => ⊤.toMultiequalizer P ≫ colimit.ι (J.diagram P X.unop) { unop := ⊤ }, naturality := ⋯ }
            X.unop).app
        S ≫
      Multiequalizer.ι (S.unop.index (J.plusObj P)) I =
    ((colimit.ι (J.diagram P X.unop) S ≫ ⊤.toMultiequalizer (J.plusObj P)) ≫
        (J.diagram (J.plusObj P) X.unop).map e.op) ≫
      Multiequalizer.ι (S.unop.index (J.plusObj P)) I
state_after: case w.h.e_a
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
X : Cᵒᵖ
S : (J.Cover X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE ⋯
I : (S.unop.index (J.plusObj P)).L
⊢ Multiequalizer.ι (S.unop.index P) I ≫
      { app := fun X => ⊤.toMultiequalizer P ≫ colimit.ι (J.diagram P X.unop) { unop := ⊤ }, naturality := ⋯ }.app
        { unop := I.Y } =
    ((colimit.ι (J.diagram P X.unop) S ≫ ⊤.toMultiequalizer (J.plusObj P)) ≫
        (J.diagram (J.plusObj P) X.unop).map e.op) ≫
      Multiequalizer.ι (S.unop.index (J.plusObj 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.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
X : Cᵒᵖ
S : (J.Cover X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE ⋯
I : (S.unop.index (J.plusObj P)).L
⊢ Multiequalizer.ι (S.unop.index P) I ≫
      { app := fun X => ⊤.toMultiequalizer P ≫ colimit.ι (J.diagram P X.unop) { unop := ⊤ }, naturality := ⋯ }.app
        { unop := I.Y } =
    ((colimit.ι (J.diagram P X.unop) S ≫ ⊤.toMultiequalizer (J.plusObj P)) ≫
        (J.diagram (J.plusObj P) X.unop).map e.op) ≫
      Multiequalizer.ι (S.unop.index (J.plusObj P)) I
state_after: case w.h.e_a
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
X : Cᵒᵖ
S : (J.Cover X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE ⋯
I : (S.unop.index (J.plusObj P)).L
⊢ Multiequalizer.ι (S.unop.index P) I ≫ ⊤.toMultiequalizer P ≫ colimit.ι (J.diagram P I.Y) { unop := ⊤ } =
    colimit.ι (J.diagram P X.unop) S ≫ (J.plusObj P).map (Cover.Arrow.map I e.op.unop).f.op

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.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
X : Cᵒᵖ
S : (J.Cover X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE ⋯
I : (S.unop.index (J.plusObj P)).L
⊢ Multiequalizer.ι (S.unop.index P) I ≫ ⊤.toMultiequalizer P ≫ colimit.ι (J.diagram P I.Y) { unop := ⊤ } =
    colimit.ι (J.diagram P X.unop) S ≫ (J.plusObj P).map (Cover.Arrow.map I e.op.unop).f.op
state_after: case w.h.e_a
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
X : Cᵒᵖ
S : (J.Cover X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE ⋯
I : (S.unop.index (J.plusObj P)).L
ee : (J.pullback (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ := homOfLE ⋯
⊢ Multiequalizer.ι (S.unop.index P) I ≫ ⊤.toMultiequalizer P ≫ colimit.ι (J.diagram P I.Y) { unop := ⊤ } =
    colimit.ι (J.diagram P X.unop) S ≫ (J.plusObj P).map (Cover.Arrow.map I e.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.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
X : Cᵒᵖ
S : (J.Cover X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE ⋯
I : (S.unop.index (J.plusObj P)).L
ee : (J.pullback (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ := homOfLE ⋯
⊢ Multiequalizer.ι (S.unop.index P) I ≫ ⊤.toMultiequalizer P ≫ colimit.ι (J.diagram P I.Y) { unop := ⊤ } =
    colimit.ι (J.diagram P X.unop) S ≫ (J.plusObj P).map (Cover.Arrow.map I e.op.unop).f.op
state_after: case w.h.e_a
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
X : Cᵒᵖ
S : (J.Cover X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE ⋯
I : (S.unop.index (J.plusObj P)).L
ee : (J.pullback (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ := homOfLE ⋯
⊢ ((Multiequalizer.ι (S.unop.index P) I ≫ ⊤.toMultiequalizer P) ≫ (J.diagram P I.Y).map ee.op) ≫
      colimit.ι (J.diagram P I.Y) { unop := (J.pullback (Cover.Arrow.map I e).f).obj S.unop } =
    Multiequalizer.lift (((J.pullback (Cover.Arrow.map I e.op.unop).f.op.unop).op.obj S).unop.index P)
        ((J.diagram P X.unop).obj S) (fun I_1 => Multiequalizer.ι (S.unop.index P) (Cover.Arrow.base I_1)) ⋯ ≫
      colimit.ι (J.diagram P { unop := (Cover.Arrow.map I e.op.unop).Y }.unop)
        ((J.pullback (Cover.Arrow.map I e.op.unop).f.op.unop).op.obj S)

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

tactic: refine Multiequalizer.hom_ext _ _ _ (fun II => ?_)
state_before: case w.h.e_a.e_a
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
X : Cᵒᵖ
S : (J.Cover X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE ⋯
I : (S.unop.index (J.plusObj P)).L
ee : (J.pullback (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ := homOfLE ⋯
⊢ (Multiequalizer.ι (S.unop.index P) I ≫ ⊤.toMultiequalizer P) ≫ (J.diagram P I.Y).map ee.op =
    Multiequalizer.lift (((J.pullback (Cover.Arrow.map I e.op.unop).f.op.unop).op.obj S).unop.index P)
      ((J.diagram P X.unop).obj S) (fun I_1 => Multiequalizer.ι (S.unop.index P) (Cover.Arrow.base I_1)) ⋯
state_after: case w.h.e_a.e_a
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
X : Cᵒᵖ
S : (J.Cover X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE ⋯
I : (S.unop.index (J.plusObj P)).L
ee : (J.pullback (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ := homOfLE ⋯
II : ({ unop := (J.pullback (Cover.Arrow.map I e).f).obj S.unop }.unop.index P).L
⊢ ((Multiequalizer.ι (S.unop.index P) I ≫ ⊤.toMultiequalizer P) ≫ (J.diagram P I.Y).map ee.op) ≫
      Multiequalizer.ι ({ unop := (J.pullback (Cover.Arrow.map I e).f).obj S.unop }.unop.index P) II =
    Multiequalizer.lift (((J.pullback (Cover.Arrow.map I e.op.unop).f.op.unop).op.obj S).unop.index P)
        ((J.diagram P X.unop).obj S) (fun I_1 => Multiequalizer.ι (S.unop.index P) (Cover.Arrow.base I_1)) ⋯ ≫
      Multiequalizer.ι ({ unop := (J.pullback (Cover.Arrow.map I e).f).obj S.unop }.unop.index P) II

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

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

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

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

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

tactic: simp
state_before: case h.e'_3.h
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
X : Cᵒᵖ
S : (J.Cover X.unop)ᵒᵖ
e : S.unop ⟶ ⊤ := homOfLE ⋯
I : (S.unop.index (J.plusObj P)).L
ee : (J.pullback (Cover.Arrow.map I e).f).obj S.unop ⟶ ⊤ := homOfLE ⋯
II : ({ unop := (J.pullback (Cover.Arrow.map I e).f).obj S.unop }.unop.index P).L
e_1✝ :
  ((J.diagram P X.unop).obj S ⟶ ({ unop := (J.pullback (Cover.Arrow.map I e).f).obj S.unop }.unop.index P).left II) =
    (multiequalizer (S.unop.index P) ⟶
      (S.unop.index P).right
        { fst := I, snd := Cover.Arrow.base II, r := { Z := II.Y, g₁ := II.f, g₂ := 𝟙 II.Y, w := ⋯ } })
⊢ Multiequalizer.lift ((S.unop.pullback I.f).index P) (multiequalizer (S.unop.index P))
        (fun I_1 => Multiequalizer.ι (S.unop.index P) I_1.base) ⋯ ≫
      Multiequalizer.ι ((S.unop.pullback I.f).index P) II =
    Multiequalizer.ι (S.unop.index P) (Cover.Arrow.base II) ≫ P.map (𝟙 { unop := II.Y })
state_after: no goals