l3lab/ntp-mathlib huggingface dataset:
/-- The isomorphism between `P⁺ ⋙ F` and `(P ⋙ F)⁺`. -/
def plusCompIso : J.plusObj P ⋙ F ≅ J.plusObj (P ⋙ F) :=
  NatIso.ofComponents
    (fun X => by
      refine' _ ≪≫ HasColimit.isoOfNatIso (J.diagramCompIso F P X.unop)
      refine'
        (isColimitOfPreserves F
              (colimit.isColimit (J.diagram P (unop X)))).coconePointUniqueUpToIso
          (colimit.isColimit _))
    (by
      intro X Y f
      

Proof state:
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
X Y : Cᵒᵖ
f : X ⟶ Y
⊢ (plusObj J P ⋙ F).map f ≫
      ((fun X =>
            IsColimit.coconePointUniqueUpToIso (isColimitOfPreserves F (colimit.isColimit (diagram J P X.unop)))
                (colimit.isColimit (diagram J P X.unop ⋙ F)) ≪≫
              HasColimit.isoOfNatIso (diagramCompIso J F P X.unop))
          Y).hom =
    ((fun X =>
            IsColimit.coconePointUniqueUpToIso (isColimitOfPreserves F (colimit.isColimit (diagram J P X.unop)))
                (colimit.isColimit (diagram J P X.unop ⋙ F)) ≪≫
              HasColimit.isoOfNatIso (diagramCompIso J F P X.unop))
          X).hom ≫
      (plusObj J (P ⋙ F)).map f

Next tactic:
apply (isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).hom_ext
/-- The isomorphism between `P⁺ ⋙ F` and `(P ⋙ F)⁺`. -/
def plusCompIso : J.plusObj P ⋙ F ≅ J.plusObj (P ⋙ F) :=
  NatIso.ofComponents
    (fun X => by
      refine' _ ≪≫ HasColimit.isoOfNatIso (J.diagramCompIso F P X.unop)
      refine'
        (isColimitOfPreserves F
              (colimit.isColimit (J.diagram P (unop X)))).coconePointUniqueUpToIso
          (colimit.isColimit _))
    (by
      intro X Y f
      apply (isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).hom_ext
      

Proof state:
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
X Y : Cᵒᵖ
f : X ⟶ Y
⊢ ∀ (j : (Cover J X.unop)ᵒᵖ),
    (F.mapCocone (colimit.cocone (diagram J P X.unop))).ι.app j ≫
        (plusObj J P ⋙ F).map f ≫
          ((fun X =>
                IsColimit.coconePointUniqueUpToIso (isColimitOfPreserves F (colimit.isColimit (diagram J P X.unop)))
                    (colimit.isColimit (diagram J P X.unop ⋙ F)) ≪≫
                  HasColimit.isoOfNatIso (diagramCompIso J F P X.unop))
              Y).hom =
      (F.mapCocone (colimit.cocone (diagram J P X.unop))).ι.app j ≫
        ((fun X =>
                IsColimit.coconePointUniqueUpToIso (isColimitOfPreserves F (colimit.isColimit (diagram J P X.unop)))
                    (colimit.isColimit (diagram J P X.unop ⋙ F)) ≪≫
                  HasColimit.isoOfNatIso (diagramCompIso J F P X.unop))
              X).hom ≫
          (plusObj J (P ⋙ F)).map f

Next tactic:
intro W
/-- The isomorphism between `P⁺ ⋙ F` and `(P ⋙ F)⁺`. -/
def plusCompIso : J.plusObj P ⋙ F ≅ J.plusObj (P ⋙ F) :=
  NatIso.ofComponents
    (fun X => by
      refine' _ ≪≫ HasColimit.isoOfNatIso (J.diagramCompIso F P X.unop)
      refine'
        (isColimitOfPreserves F
              (colimit.isColimit (J.diagram P (unop X)))).coconePointUniqueUpToIso
          (colimit.isColimit _))
    (by
      intro X Y f
      apply (isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).hom_ext
      intro W
      

Proof state:
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
X Y : Cᵒᵖ
f : X ⟶ Y
W : (Cover J X.unop)ᵒᵖ
⊢ (F.mapCocone (colimit.cocone (diagram J P X.unop))).ι.app W ≫
      (plusObj J P ⋙ F).map f ≫
        ((fun X =>
              IsColimit.coconePointUniqueUpToIso (isColimitOfPreserves F (colimit.isColimit (diagram J P X.unop)))
                  (colimit.isColimit (diagram J P X.unop ⋙ F)) ≪≫
                HasColimit.isoOfNatIso (diagramCompIso J F P X.unop))
            Y).hom =
    (F.mapCocone (colimit.cocone (diagram J P X.unop))).ι.app W ≫
      ((fun X =>
              IsColimit.coconePointUniqueUpToIso (isColimitOfPreserves F (colimit.isColimit (diagram J P X.unop)))
                  (colimit.isColimit (diagram J P X.unop ⋙ F)) ≪≫
                HasColimit.isoOfNatIso (diagramCompIso J F P X.unop))
            X).hom ≫
        (plusObj J (P ⋙ F)).map f

Next tactic:
dsimp [plusObj, plusMap]
/-- The isomorphism between `P⁺ ⋙ F` and `(P ⋙ F)⁺`. -/
def plusCompIso : J.plusObj P ⋙ F ≅ J.plusObj (P ⋙ F) :=
  NatIso.ofComponents
    (fun X => by
      refine' _ ≪≫ HasColimit.isoOfNatIso (J.diagramCompIso F P X.unop)
      refine'
        (isColimitOfPreserves F
              (colimit.isColimit (J.diagram P (unop X)))).coconePointUniqueUpToIso
          (colimit.isColimit _))
    (by
      intro X Y f
      apply (isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).hom_ext
      intro W
      dsimp [plusObj, plusMap]
      

Proof state:
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
X Y : Cᵒᵖ
f : X ⟶ Y
W : (Cover J X.unop)ᵒᵖ
⊢ F.map (colimit.ι (diagram J P X.unop) W) ≫
      F.map (colimMap (diagramPullback J P f.unop) ≫ colimit.pre (diagram J P Y.unop) (pullback J f.unop).op) ≫
        (IsColimit.coconePointUniqueUpToIso (isColimitOfPreserves F (colimit.isColimit (diagram J P Y.unop)))
              (colimit.isColimit (diagram J P Y.unop ⋙ F))).hom ≫
          (HasColimit.isoOfNatIso (diagramCompIso J F P Y.unop)).hom =
    F.map (colimit.ι (diagram J P X.unop) W) ≫
      ((IsColimit.coconePointUniqueUpToIso (isColimitOfPreserves F (colimit.isColimit (diagram J P X.unop)))
              (colimit.isColimit (diagram J P X.unop ⋙ F))).hom ≫
          (HasColimit.isoOfNatIso (diagramCompIso J F P X.unop)).hom) ≫
        colimMap (diagramPullback J (P ⋙ F) f.unop) ≫ colimit.pre (diagram J (P ⋙ F) Y.unop) (pullback J f.unop).op

Next tactic:
simp only [Functor.map_comp, Category.assoc]
/-- The isomorphism between `P⁺ ⋙ F` and `(P ⋙ F)⁺`. -/
def plusCompIso : J.plusObj P ⋙ F ≅ J.plusObj (P ⋙ F) :=
  NatIso.ofComponents
    (fun X => by
      refine' _ ≪≫ HasColimit.isoOfNatIso (J.diagramCompIso F P X.unop)
      refine'
        (isColimitOfPreserves F
              (colimit.isColimit (J.diagram P (unop X)))).coconePointUniqueUpToIso
          (colimit.isColimit _))
    (by
      intro X Y f
      apply (isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).hom_ext
      intro W
      dsimp [plusObj, plusMap]
      simp only [Functor.map_comp, Category.assoc]
      

Proof state:
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
X Y : Cᵒᵖ
f : X ⟶ Y
W : (Cover J X.unop)ᵒᵖ
⊢ F.map (colimit.ι (diagram J P X.unop) W) ≫
      F.map (colimMap (diagramPullback J P f.unop)) ≫
        F.map (colimit.pre (diagram J P Y.unop) (pullback J f.unop).op) ≫
          (IsColimit.coconePointUniqueUpToIso (isColimitOfPreserves F (colimit.isColimit (diagram J P Y.unop)))
                (colimit.isColimit (diagram J P Y.unop ⋙ F))).hom ≫
            (HasColimit.isoOfNatIso (diagramCompIso J F P Y.unop)).hom =
    F.map (colimit.ι (diagram J P X.unop) W) ≫
      (IsColimit.coconePointUniqueUpToIso (isColimitOfPreserves F (colimit.isColimit (diagram J P X.unop)))
            (colimit.isColimit (diagram J P X.unop ⋙ F))).hom ≫
        (HasColimit.isoOfNatIso (diagramCompIso J F P X.unop)).hom ≫
          colimMap (diagramPullback J (P ⋙ F) f.unop) ≫ colimit.pre (diagram J (P ⋙ F) Y.unop) (pullback J f.unop).op

Next tactic:
slice_rhs 1 2 =>
        erw [(isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).fac]
/-- The isomorphism between `P⁺ ⋙ F` and `(P ⋙ F)⁺`. -/
def plusCompIso : J.plusObj P ⋙ F ≅ J.plusObj (P ⋙ F) :=
  NatIso.ofComponents
    (fun X => by
      refine' _ ≪≫ HasColimit.isoOfNatIso (J.diagramCompIso F P X.unop)
      refine'
        (isColimitOfPreserves F
              (colimit.isColimit (J.diagram P (unop X)))).coconePointUniqueUpToIso
          (colimit.isColimit _))
    (by
      intro X Y f
      apply (isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).hom_ext
      intro W
      dsimp [plusObj, plusMap]
      simp only [Functor.map_comp, Category.assoc]
      slice_rhs 1 2 =>
        erw [(isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).fac]
      

Proof state:
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
X Y : Cᵒᵖ
f : X ⟶ Y
W : (Cover J X.unop)ᵒᵖ
⊢ F.map (colimit.ι (diagram J P X.unop) W) ≫
      F.map (colimMap (diagramPullback J P f.unop)) ≫
        F.map (colimit.pre (diagram J P Y.unop) (pullback J f.unop).op) ≫
          (IsColimit.coconePointUniqueUpToIso (isColimitOfPreserves F (colimit.isColimit (diagram J P Y.unop)))
                (colimit.isColimit (diagram J P Y.unop ⋙ F))).hom ≫
            (HasColimit.isoOfNatIso (diagramCompIso J F P Y.unop)).hom =
    (((colimit.cocone (diagram J P X.unop ⋙ F)).ι.app W ≫ (HasColimit.isoOfNatIso (diagramCompIso J F P X.unop)).hom) ≫
        colimMap (diagramPullback J (P ⋙ F) f.unop)) ≫
      colimit.pre (diagram J (P ⋙ F) Y.unop) (pullback J f.unop).op

Next tactic:
slice_lhs 1 3 =>
        simp only [← F.map_comp]
        dsimp [colimMap, IsColimit.map, colimit.pre]
        simp only [colimit.ι_desc_assoc, colimit.ι_desc]
        dsimp [Cocones.precompose]
        simp only [Category.assoc, colimit.ι_desc]
        dsimp [Cocone.whisker]
        rw [F.map_comp]
/-- The isomorphism between `P⁺ ⋙ F` and `(P ⋙ F)⁺`. -/
def plusCompIso : J.plusObj P ⋙ F ≅ J.plusObj (P ⋙ F) :=
  NatIso.ofComponents
    (fun X => by
      refine' _ ≪≫ HasColimit.isoOfNatIso (J.diagramCompIso F P X.unop)
      refine'
        (isColimitOfPreserves F
              (colimit.isColimit (J.diagram P (unop X)))).coconePointUniqueUpToIso
          (colimit.isColimit _))
    (by
      intro X Y f
      apply (isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).hom_ext
      intro W
      dsimp [plusObj, plusMap]
      simp only [Functor.map_comp, Category.assoc]
      slice_rhs 1 2 =>
        erw [(isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).fac]
      slice_lhs 1 3 =>
        simp only [← F.map_comp]
        dsimp [colimMap, IsColimit.map, colimit.pre]
        simp only [colimit.ι_desc_assoc, colimit.ι_desc]
        dsimp [Cocones.precompose]
        simp only [Category.assoc, colimit.ι_desc]
        dsimp [Cocone.whisker]
        rw [F.map_comp]
      

Proof state:
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
X Y : Cᵒᵖ
f : X ⟶ Y
W : (Cover J X.unop)ᵒᵖ
⊢ ((F.map
            (Multiequalizer.lift (Cover.index (Cover.pullback W.unop f.unop) P) (multiequalizer (Cover.index W.unop P))
              (fun I => Multiequalizer.ι (Cover.index W.unop P) (Cover.Arrow.base I))
              (_ :
                ∀ (I : (Cover.index ((pullback J f.unop).op.obj W).unop P).R),
                  Multiequalizer.ι (Cover.index W.unop P)
                        (MulticospanIndex.fstTo (Cover.index W.unop P) (Cover.Relation.base I)) ≫
                      MulticospanIndex.fst (Cover.index W.unop P) (Cover.Relation.base I) =
                    Multiequalizer.ι (Cover.index W.unop P)
                        (MulticospanIndex.sndTo (Cover.index W.unop P) (Cover.Relation.base I)) ≫
                      MulticospanIndex.snd (Cover.index W.unop P) (Cover.Relation.base I))) ≫
          F.map (colimit.ι (diagram J P Y.unop) (op (Cover.pullback W.unop f.unop)))) ≫
        (IsColimit.coconePointUniqueUpToIso (isColimitOfPreserves F (colimit.isColimit (diagram J P Y.unop)))
            (colimit.isColimit (diagram J P Y.unop ⋙ F))).hom) ≫
      (HasColimit.isoOfNatIso (diagramCompIso J F P Y.unop)).hom =
    (((colimit.cocone (diagram J P X.unop ⋙ F)).ι.app W ≫ (HasColimit.isoOfNatIso (diagramCompIso J F P X.unop)).hom) ≫
        colimMap (diagramPullback J (P ⋙ F) f.unop)) ≫
      colimit.pre (diagram J (P ⋙ F) Y.unop) (pullback J f.unop).op

Next tactic:
simp only [Category.assoc]
/-- The isomorphism between `P⁺ ⋙ F` and `(P ⋙ F)⁺`. -/
def plusCompIso : J.plusObj P ⋙ F ≅ J.plusObj (P ⋙ F) :=
  NatIso.ofComponents
    (fun X => by
      refine' _ ≪≫ HasColimit.isoOfNatIso (J.diagramCompIso F P X.unop)
      refine'
        (isColimitOfPreserves F
              (colimit.isColimit (J.diagram P (unop X)))).coconePointUniqueUpToIso
          (colimit.isColimit _))
    (by
      intro X Y f
      apply (isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).hom_ext
      intro W
      dsimp [plusObj, plusMap]
      simp only [Functor.map_comp, Category.assoc]
      slice_rhs 1 2 =>
        erw [(isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).fac]
      slice_lhs 1 3 =>
        simp only [← F.map_comp]
        dsimp [colimMap, IsColimit.map, colimit.pre]
        simp only [colimit.ι_desc_assoc, colimit.ι_desc]
        dsimp [Cocones.precompose]
        simp only [Category.assoc, colimit.ι_desc]
        dsimp [Cocone.whisker]
        rw [F.map_comp]
      simp only [Category.assoc]
      slice_lhs 2 3 =>
        erw [(isColimitOfPreserves F (colimit.isColimit (J.diagram P Y.unop))).fac]
      

Proof state:
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
X Y : Cᵒᵖ
f : X ⟶ Y
W : (Cover J X.unop)ᵒᵖ
⊢ F.map
        (Multiequalizer.lift (Cover.index (Cover.pullback W.unop f.unop) P) (multiequalizer (Cover.index W.unop P))
          (fun I => Multiequalizer.ι (Cover.index W.unop P) (Cover.Arrow.base I))
          (_ :
            ∀ (I : (Cover.index ((pullback J f.unop).op.obj W).unop P).R),
              Multiequalizer.ι (Cover.index W.unop P)
                    (MulticospanIndex.fstTo (Cover.index W.unop P) (Cover.Relation.base I)) ≫
                  MulticospanIndex.fst (Cover.index W.unop P) (Cover.Relation.base I) =
                Multiequalizer.ι (Cover.index W.unop P)
                    (MulticospanIndex.sndTo (Cover.index W.unop P) (Cover.Relation.base I)) ≫
                  MulticospanIndex.snd (Cover.index W.unop P) (Cover.Relation.base I))) ≫
      (colimit.cocone (diagram J P Y.unop ⋙ F)).ι.app (op (Cover.pullback W.unop f.unop)) ≫
        (HasColimit.isoOfNatIso (diagramCompIso J F P Y.unop)).hom =
    (colimit.cocone (diagram J P X.unop ⋙ F)).ι.app W ≫
      (HasColimit.isoOfNatIso (diagramCompIso J F P X.unop)).hom ≫
        colimMap (diagramPullback J (P ⋙ F) f.unop) ≫ colimit.pre (diagram J (P ⋙ F) Y.unop) (pullback J f.unop).op

Next tactic:
dsimp
@[reassoc (attr := simp)]
theorem ι_plusCompIso_hom (X) (W) :
    F.map (colimit.ι _ W) ≫ (J.plusCompIso F P).hom.app X =
      (J.diagramCompIso F P X.unop).hom.app W ≫ colimit.ι _ W := by
  

Proof state:
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
X : Cᵒᵖ
W : (Cover J X.unop)ᵒᵖ
⊢ F.map (colimit.ι (diagram J P X.unop) W) ≫ (plusCompIso J F P).hom.app X =
    (diagramCompIso J F P X.unop).hom.app W ≫ colimit.ι (diagram J (P ⋙ F) X.unop) W

Next tactic:
delta diagramCompIso plusCompIso
@[reassoc (attr := simp)]
theorem ι_plusCompIso_hom (X) (W) :
    F.map (colimit.ι _ W) ≫ (J.plusCompIso F P).hom.app X =
      (J.diagramCompIso F P X.unop).hom.app W ≫ colimit.ι _ W := by
  delta diagramCompIso plusCompIso
  

Proof state:
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
X : Cᵒᵖ
W : (Cover J X.unop)ᵒᵖ
⊢ F.map (colimit.ι (diagram J P X.unop) W) ≫
      (NatIso.ofComponents fun X =>
              IsColimit.coconePointUniqueUpToIso (isColimitOfPreserves F (colimit.isColimit (diagram J P X.unop)))
                  (colimit.isColimit (diagram J P X.unop ⋙ F)) ≪≫
                HasColimit.isoOfNatIso
                  (NatIso.ofComponents fun W =>
                    IsLimit.conePointUniqueUpToIso
                        (isLimitOfPreserves F (limit.isLimit (MulticospanIndex.multicospan (Cover.index W.unop P))))
                        (limit.isLimit (MulticospanIndex.multicospan (Cover.index W.unop P) ⋙ F)) ≪≫
                      HasLimit.isoOfNatIso (Cover.multicospanComp F P W.unop).symm)).hom.app
        X =
    (NatIso.ofComponents fun W =>
              IsLimit.conePointUniqueUpToIso
                  (isLimitOfPreserves F (limit.isLimit (MulticospanIndex.multicospan (Cover.index W.unop P))))
                  (limit.isLimit (MulticospanIndex.multicospan (Cover.index W.unop P) ⋙ F)) ≪≫
                HasLimit.isoOfNatIso (Cover.multicospanComp F P W.unop).symm).hom.app
        W ≫
      colimit.ι (diagram J (P ⋙ F) X.unop) W

Next tactic:
simp only [IsColimit.descCoconeMorphism_hom, IsColimit.uniqueUpToIso_hom,
    Cocones.forget_map, Iso.trans_hom, NatIso.ofComponents_hom_app, Functor.mapIso_hom, ←
    Category.assoc]