l3lab/ntp-mathlib huggingface dataset:
@[reassoc (attr := simp)]
theorem toPlus_naturality {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) :
    η ≫ J.toPlus Q = J.toPlus _ ≫ J.plusMap η := by
  ext
  dsimp [toPlus, plusMap]
  

Proof state:
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 : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
x✝ : Cᵒᵖ
⊢ η.app x✝ ≫ Cover.toMultiequalizer ⊤ Q ≫ colimit.ι (diagram J Q x✝.unop) (op ⊤) =
    (Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P x✝.unop) (op ⊤)) ≫ colimMap (diagramNatTrans J η x✝.unop)

Next tactic:
delta Cover.toMultiequalizer
@[reassoc (attr := simp)]
theorem toPlus_naturality {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) :
    η ≫ J.toPlus Q = J.toPlus _ ≫ J.plusMap η := by
  ext
  dsimp [toPlus, plusMap]
  delta Cover.toMultiequalizer
  

Proof state:
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 : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
x✝ : Cᵒᵖ
⊢ η.app x✝ ≫
      Multiequalizer.lift (Cover.index ⊤ Q) (Q.obj (op x✝.unop)) (fun I => Q.map I.f.op)
          (_ :
            ∀ (I : (Cover.index ⊤ Q).R),
              (fun I => Q.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ Q) I) ≫
                  MulticospanIndex.fst (Cover.index ⊤ Q) I =
                (fun I => Q.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ Q) I) ≫
                  MulticospanIndex.snd (Cover.index ⊤ Q) I) ≫
        colimit.ι (diagram J Q x✝.unop) (op ⊤) =
    (Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op x✝.unop)) (fun I => P.map I.f.op)
          (_ :
            ∀ (I : (Cover.index ⊤ P).R),
              (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                  MulticospanIndex.fst (Cover.index ⊤ P) I =
                (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                  MulticospanIndex.snd (Cover.index ⊤ P) I) ≫
        colimit.ι (diagram J P x✝.unop) (op ⊤)) ≫
      colimMap (diagramNatTrans J η x✝.unop)

Next tactic:
simp only [ι_colimMap, Category.assoc]
@[reassoc (attr := simp)]
theorem toPlus_naturality {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) :
    η ≫ J.toPlus Q = J.toPlus _ ≫ J.plusMap η := by
  ext
  dsimp [toPlus, plusMap]
  delta Cover.toMultiequalizer
  simp only [ι_colimMap, Category.assoc]
  

Proof state:
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 : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
x✝ : Cᵒᵖ
⊢ η.app x✝ ≫
      Multiequalizer.lift (Cover.index ⊤ Q) (Q.obj (op x✝.unop)) (fun I => Q.map I.f.op)
          (_ :
            ∀ (I : (Cover.index ⊤ Q).R),
              (fun I => Q.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ Q) I) ≫
                  MulticospanIndex.fst (Cover.index ⊤ Q) I =
                (fun I => Q.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ Q) I) ≫
                  MulticospanIndex.snd (Cover.index ⊤ Q) I) ≫
        colimit.ι (diagram J Q x✝.unop) (op ⊤) =
    Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op x✝.unop)) (fun I => P.map I.f.op)
        (_ :
          ∀ (I : (Cover.index ⊤ P).R),
            (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                MulticospanIndex.fst (Cover.index ⊤ P) I =
              (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                MulticospanIndex.snd (Cover.index ⊤ P) I) ≫
      (diagramNatTrans J η x✝.unop).app (op ⊤) ≫ colimit.ι (diagram J Q x✝.unop) (op ⊤)

Next tactic:
simp_rw [← Category.assoc]
@[reassoc (attr := simp)]
theorem toPlus_naturality {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) :
    η ≫ J.toPlus Q = J.toPlus _ ≫ J.plusMap η := by
  ext
  dsimp [toPlus, plusMap]
  delta Cover.toMultiequalizer
  simp only [ι_colimMap, Category.assoc]
  simp_rw [← Category.assoc]
  

Proof state:
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 : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
x✝ : Cᵒᵖ
⊢ (η.app x✝ ≫
        Multiequalizer.lift (Cover.index ⊤ Q) (Q.obj (op x✝.unop)) (fun I => Q.map I.f.op)
          (_ :
            ∀ (I : (Cover.index ⊤ Q).R),
              (fun I => Q.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ Q) I) ≫
                  MulticospanIndex.fst (Cover.index ⊤ Q) I =
                (fun I => Q.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ Q) I) ≫
                  MulticospanIndex.snd (Cover.index ⊤ Q) I)) ≫
      colimit.ι (diagram J Q x✝.unop) (op ⊤) =
    (Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op x✝.unop)) (fun I => P.map I.f.op)
          (_ :
            ∀ (I : (Cover.index ⊤ P).R),
              (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                  MulticospanIndex.fst (Cover.index ⊤ P) I =
                (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                  MulticospanIndex.snd (Cover.index ⊤ P) I) ≫
        (diagramNatTrans J η x✝.unop).app (op ⊤)) ≫
      colimit.ι (diagram J Q x✝.unop) (op ⊤)

Next tactic:
congr 1
@[reassoc (attr := simp)]
theorem toPlus_naturality {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) :
    η ≫ J.toPlus Q = J.toPlus _ ≫ J.plusMap η := by
  ext
  dsimp [toPlus, plusMap]
  delta Cover.toMultiequalizer
  simp only [ι_colimMap, Category.assoc]
  simp_rw [← Category.assoc]
  congr 1
  

Proof state:
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 : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
x✝ : Cᵒᵖ
⊢ η.app x✝ ≫
      Multiequalizer.lift (Cover.index ⊤ Q) (Q.obj (op x✝.unop)) (fun I => Q.map I.f.op)
        (_ :
          ∀ (I : (Cover.index ⊤ Q).R),
            (fun I => Q.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ Q) I) ≫
                MulticospanIndex.fst (Cover.index ⊤ Q) I =
              (fun I => Q.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ Q) I) ≫
                MulticospanIndex.snd (Cover.index ⊤ Q) I) =
    Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op x✝.unop)) (fun I => P.map I.f.op)
        (_ :
          ∀ (I : (Cover.index ⊤ P).R),
            (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                MulticospanIndex.fst (Cover.index ⊤ P) I =
              (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                MulticospanIndex.snd (Cover.index ⊤ P) I) ≫
      (diagramNatTrans J η x✝.unop).app (op ⊤)

Next tactic:
exact Multiequalizer.hom_ext _ _ _ (fun I => by dsimp; simp)
@[reassoc (attr := simp)]
theorem toPlus_naturality {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) :
    η ≫ J.toPlus Q = J.toPlus _ ≫ J.plusMap η := by
  ext
  dsimp [toPlus, plusMap]
  delta Cover.toMultiequalizer
  simp only [ι_colimMap, Category.assoc]
  simp_rw [← Category.assoc]
  congr 1
  exact Multiequalizer.hom_ext _ _ _ (fun I => by 

Proof state:
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 : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
x✝ : Cᵒᵖ
I : (Cover.index ⊤ Q).L
⊢ (η.app x✝ ≫
        Multiequalizer.lift (Cover.index ⊤ Q) (Q.obj (op x✝.unop)) (fun I => Q.map I.f.op)
          (_ :
            ∀ (I : (Cover.index ⊤ Q).R),
              (fun I => Q.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ Q) I) ≫
                  MulticospanIndex.fst (Cover.index ⊤ Q) I =
                (fun I => Q.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ Q) I) ≫
                  MulticospanIndex.snd (Cover.index ⊤ Q) I)) ≫
      Multiequalizer.ι (Cover.index ⊤ Q) I =
    (Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op x✝.unop)) (fun I => P.map I.f.op)
          (_ :
            ∀ (I : (Cover.index ⊤ P).R),
              (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                  MulticospanIndex.fst (Cover.index ⊤ P) I =
                (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                  MulticospanIndex.snd (Cover.index ⊤ P) I) ≫
        (diagramNatTrans J η x✝.unop).app (op ⊤)) ≫
      Multiequalizer.ι (Cover.index ⊤ Q) I

Next tactic:
dsimp
@[reassoc (attr := simp)]
theorem toPlus_naturality {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) :
    η ≫ J.toPlus Q = J.toPlus _ ≫ J.plusMap η := by
  ext
  dsimp [toPlus, plusMap]
  delta Cover.toMultiequalizer
  simp only [ι_colimMap, Category.assoc]
  simp_rw [← Category.assoc]
  congr 1
  exact Multiequalizer.hom_ext _ _ _ (fun I => by dsimp; 

Proof state:
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 : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
x✝ : Cᵒᵖ
I : (Cover.index ⊤ Q).L
⊢ (η.app x✝ ≫
        Multiequalizer.lift (Cover.index ⊤ Q) (Q.obj x✝) (fun I => Q.map I.f.op)
          (_ :
            ∀ (I : (Cover.index ⊤ Q).R),
              (fun I => Q.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ Q) I) ≫
                  MulticospanIndex.fst (Cover.index ⊤ Q) I =
                (fun I => Q.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ Q) I) ≫
                  MulticospanIndex.snd (Cover.index ⊤ Q) I)) ≫
      Multiequalizer.ι (Cover.index ⊤ Q) I =
    (Multiequalizer.lift (Cover.index ⊤ P) (P.obj x✝) (fun I => P.map I.f.op)
          (_ :
            ∀ (I : (Cover.index ⊤ P).R),
              (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                  MulticospanIndex.fst (Cover.index ⊤ P) I =
                (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                  MulticospanIndex.snd (Cover.index ⊤ P) I) ≫
        Multiequalizer.lift (Cover.index ⊤ Q) (multiequalizer (Cover.index ⊤ P))
          (fun i => Multiequalizer.ι (Cover.index ⊤ P) i ≫ η.app (op i.Y))
          (_ :
            ∀ (i : (Cover.index (op ⊤).unop Q).R),
              (fun i => Multiequalizer.ι (Cover.index (op ⊤).unop P) i ≫ η.app (op i.Y))
                    (MulticospanIndex.fstTo (Cover.index (op ⊤).unop Q) i) ≫
                  MulticospanIndex.fst (Cover.index (op ⊤).unop Q) i =
                (fun i => Multiequalizer.ι (Cover.index (op ⊤).unop P) i ≫ η.app (op i.Y))
                    (MulticospanIndex.sndTo (Cover.index (op ⊤).unop Q) i) ≫
                  MulticospanIndex.snd (Cover.index (op ⊤).unop Q) i)) ≫
      Multiequalizer.ι (Cover.index ⊤ Q) I

Next tactic:
simp
/-- `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺` -/
@[simp]
theorem plusMap_toPlus : J.plusMap (J.toPlus P) = J.toPlus (J.plusObj P) := by
  

Proof state:
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 : 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)

Next tactic:
ext X : 2
/-- `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺` -/
@[simp]
theorem plusMap_toPlus : J.plusMap (J.toPlus P) = J.toPlus (J.plusObj P) := by
  ext X : 2
  

Proof state:
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 : 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

Next tactic:
refine' colimit.hom_ext (fun S => _)
/-- `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺` -/
@[simp]
theorem plusMap_toPlus : J.plusMap (J.toPlus P) = J.toPlus (J.plusObj P) := by
  ext X : 2
  refine' colimit.hom_ext (fun S => _)
  

Proof state:
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 : 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

Next tactic:
dsimp only [plusMap, toPlus]
/-- `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺` -/
@[simp]
theorem plusMap_toPlus : J.plusMap (J.toPlus P) = J.toPlus (J.plusObj P) := by
  ext X : 2
  refine' colimit.hom_ext (fun S => _)
  dsimp only [plusMap, toPlus]
  

Proof state:
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 : 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 ⊤)

Next tactic:
let e : S.unop ⟶ ⊤ := homOfLE (OrderTop.le_top _)
/-- `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺` -/
@[simp]
theorem plusMap_toPlus : J.plusMap (J.toPlus P) = J.toPlus (J.plusObj P) := by
  ext X : 2
  refine' colimit.hom_ext (fun S => _)
  dsimp only [plusMap, toPlus]
  let e : S.unop ⟶ ⊤ := homOfLE (OrderTop.le_top _)
  

Proof state:
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 : 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 ⊤)

Next tactic:
rw [ι_colimMap, ← colimit.w _ e.op, ← Category.assoc, ← Category.assoc]
/-- `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺` -/
@[simp]
theorem plusMap_toPlus : J.plusMap (J.toPlus P) = J.toPlus (J.plusObj P) := by
  ext X : 2
  refine' colimit.hom_ext (fun S => _)
  dsimp only [plusMap, toPlus]
  let e : S.unop ⟶ ⊤ := homOfLE (OrderTop.le_top _)
  rw [ι_colimMap, ← colimit.w _ e.op, ← Category.assoc, ← Category.assoc]
  

Proof state:
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 : 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) (op S.unop)

Next tactic:
congr 1
/-- `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺` -/
@[simp]
theorem plusMap_toPlus : J.plusMap (J.toPlus P) = J.toPlus (J.plusObj P) := by
  ext X : 2
  refine' colimit.hom_ext (fun S => _)
  dsimp only [plusMap, toPlus]
  let e : S.unop ⟶ ⊤ := homOfLE (OrderTop.le_top _)
  rw [ι_colimMap, ← colimit.w _ e.op, ← Category.assoc, ← Category.assoc]
  congr 1
  

Proof state:
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 : 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

Next tactic:
refine' Multiequalizer.hom_ext _ _ _ (fun I => _)
/-- `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺` -/
@[simp]
theorem plusMap_toPlus : J.plusMap (J.toPlus P) = J.toPlus (J.plusObj P) := by
  ext X : 2
  refine' colimit.hom_ext (fun S => _)
  dsimp only [plusMap, toPlus]
  let e : S.unop ⟶ ⊤ := homOfLE (OrderTop.le_top _)
  rw [ι_colimMap, ← colimit.w _ e.op, ← Category.assoc, ← Category.assoc]
  congr 1
  refine' Multiequalizer.hom_ext _ _ _ (fun I => _)
  

Proof state:
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 : 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

Next tactic:
erw [Multiequalizer.lift_ι]
/-- `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺` -/
@[simp]
theorem plusMap_toPlus : J.plusMap (J.toPlus P) = J.toPlus (J.plusObj P) := by
  ext X : 2
  refine' colimit.hom_ext (fun S => _)
  dsimp only [plusMap, toPlus]
  let e : S.unop ⟶ ⊤ := homOfLE (OrderTop.le_top _)
  rw [ι_colimMap, ← colimit.w _ e.op, ← Category.assoc, ← Category.assoc]
  congr 1
  refine' Multiequalizer.hom_ext _ _ _ (fun I => _)
  erw [Multiequalizer.lift_ι]
  

Proof state:
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 : 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 (op I.Y) =
    ((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

Next tactic:
simp only [unop_op, op_unop, diagram_map, Category.assoc, limit.lift_π,
    Multifork.ofι_π_app]
/-- `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺` -/
@[simp]
theorem plusMap_toPlus : J.plusMap (J.toPlus P) = J.toPlus (J.plusObj P) := by
  ext X : 2
  refine' colimit.hom_ext (fun S => _)
  dsimp only [plusMap, toPlus]
  let e : S.unop ⟶ ⊤ := homOfLE (OrderTop.le_top _)
  rw [ι_colimMap, ← colimit.w _ e.op, ← Category.assoc, ← Category.assoc]
  congr 1
  refine' Multiequalizer.hom_ext _ _ _ (fun I => _)
  erw [Multiequalizer.lift_ι]
  simp only [unop_op, op_unop, diagram_map, Category.assoc, limit.lift_π,
    Multifork.ofι_π_app]
  

Proof state:
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 : 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

Next tactic:
let ee : (J.pullback (I.map e).f).obj S.unop ⟶ ⊤ := homOfLE (OrderTop.le_top _)
/-- `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺` -/
@[simp]
theorem plusMap_toPlus : J.plusMap (J.toPlus P) = J.toPlus (J.plusObj P) := by
  ext X : 2
  refine' colimit.hom_ext (fun S => _)
  dsimp only [plusMap, toPlus]
  let e : S.unop ⟶ ⊤ := homOfLE (OrderTop.le_top _)
  rw [ι_colimMap, ← colimit.w _ e.op, ← Category.assoc, ← Category.assoc]
  congr 1
  refine' Multiequalizer.hom_ext _ _ _ (fun I => _)
  erw [Multiequalizer.lift_ι]
  simp only [unop_op, op_unop, diagram_map, Category.assoc, limit.lift_π,
    Multifork.ofι_π_app]
  let ee : (J.pullback (I.map e).f).obj S.unop ⟶ ⊤ := homOfLE (OrderTop.le_top _)
  

Proof state:
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 : 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

Next tactic:
erw [← colimit.w _ ee.op, ι_colimMap_assoc, colimit.ι_pre, diagramPullback_app,
    ← Category.assoc, ← Category.assoc]