/-- `(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 _)
  erw [← colimit.w _ ee.op, ι_colimMap_assoc, colimit.ι_pre, diagramPullback_app,
    ← Category.assoc, ← Category.assoc]
  congr 1
  refine' Multiequalizer.hom_ext _ _ _ (fun II => _)
  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
  · dsimp [diagram]
    cases I
    

Proof state:
case h.e'_2.h.mk
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 ≤ ⊤)
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 (op ((pullback J (Cover.Arrow.map { Y := Y✝, f := f✝, hf := hf✝ } e).f).obj S.unop)).unop P).L
e_1✝ :
  ((diagram J P X.unop).obj S ⟶
      MulticospanIndex.left
        (Cover.index (op ((pullback J (Cover.Arrow.map { Y := Y✝, f := f✝, hf := hf✝ } e).f).obj S.unop)).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 (op (Cover.pullback S.unop { Y := Y✝, f := f✝, hf := hf✝ }.f)).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) }

Next tactic:
simp only [Category.assoc, limit.lift_π, Multifork.ofι_pt, Multifork.ofι_π_app,
      Cover.Arrow.map_Y, Cover.Arrow.map_f]