l3lab/ntp-mathlib huggingface dataset:
@[reassoc (attr := simp)]
theorem plusCompIso_whiskerRight {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) :
    whiskerRight (J.plusMap η) F ≫ (J.plusCompIso F Q).hom =
      (J.plusCompIso F P).hom ≫ J.plusMap (whiskerRight η F) := by
  ext X
  apply (isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).hom_ext
  intro W
  dsimp [plusObj, plusMap]
  simp only [ι_colimMap, whiskerRight_app, ι_plusCompIso_hom_assoc,
    GrothendieckTopology.diagramNatTrans_app]
  simp only [← Category.assoc, ← F.map_comp]
  dsimp [colimMap, IsColimit.map]
  simp only [colimit.ι_desc]
  dsimp [Cocones.precompose]
  

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
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
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (Cover J X.unop)ᵒᵖ
⊢ F.map
        (Multiequalizer.lift (Cover.index W.unop Q) (multiequalizer (Cover.index W.unop P))
            (fun i => Multiequalizer.ι (Cover.index W.unop P) i ≫ η.app (op i.Y))
            (_ :
              ∀ (i : (Cover.index W.unop Q).R),
                (fun i => Multiequalizer.ι (Cover.index W.unop P) i ≫ η.app (op i.Y))
                      (MulticospanIndex.fstTo (Cover.index W.unop Q) i) ≫
                    MulticospanIndex.fst (Cover.index W.unop Q) i =
                  (fun i => Multiequalizer.ι (Cover.index W.unop P) i ≫ η.app (op i.Y))
                      (MulticospanIndex.sndTo (Cover.index W.unop Q) i) ≫
                    MulticospanIndex.snd (Cover.index W.unop Q) i) ≫
          colimit.ι (diagram J Q X.unop) W) ≫
      (plusCompIso J F Q).hom.app X =
    ((diagramCompIso J F P X.unop).hom.app W ≫
        Multiequalizer.lift (Cover.index W.unop (Q ⋙ F)) (multiequalizer (Cover.index W.unop (P ⋙ F)))
          (fun i => Multiequalizer.ι (Cover.index W.unop (P ⋙ F)) i ≫ F.map (η.app (op i.Y)))
          (_ :
            ∀ (i : (Cover.index W.unop (Q ⋙ F)).R),
              (fun i => Multiequalizer.ι (Cover.index W.unop (P ⋙ F)) i ≫ (whiskerRight η F).app (op i.Y))
                    (MulticospanIndex.fstTo (Cover.index W.unop (Q ⋙ F)) i) ≫
                  MulticospanIndex.fst (Cover.index W.unop (Q ⋙ F)) i =
                (fun i => Multiequalizer.ι (Cover.index W.unop (P ⋙ F)) i ≫ (whiskerRight η F).app (op i.Y))
                    (MulticospanIndex.sndTo (Cover.index W.unop (Q ⋙ F)) i) ≫
                  MulticospanIndex.snd (Cover.index W.unop (Q ⋙ F)) i)) ≫
      colimit.ι (diagram J (Q ⋙ F) X.unop) W

Next tactic:
simp only [Functor.map_comp, Category.assoc, ι_plusCompIso_hom]
@[reassoc (attr := simp)]
theorem plusCompIso_whiskerRight {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) :
    whiskerRight (J.plusMap η) F ≫ (J.plusCompIso F Q).hom =
      (J.plusCompIso F P).hom ≫ J.plusMap (whiskerRight η F) := by
  ext X
  apply (isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).hom_ext
  intro W
  dsimp [plusObj, plusMap]
  simp only [ι_colimMap, whiskerRight_app, ι_plusCompIso_hom_assoc,
    GrothendieckTopology.diagramNatTrans_app]
  simp only [← Category.assoc, ← F.map_comp]
  dsimp [colimMap, IsColimit.map]
  simp only [colimit.ι_desc]
  dsimp [Cocones.precompose]
  simp only [Functor.map_comp, Category.assoc, ι_plusCompIso_hom]
  

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
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
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (Cover J X.unop)ᵒᵖ
⊢ F.map
        (Multiequalizer.lift (Cover.index W.unop Q) (multiequalizer (Cover.index W.unop P))
          (fun i => Multiequalizer.ι (Cover.index W.unop P) i ≫ η.app (op i.Y))
          (_ :
            ∀ (i : (Cover.index W.unop Q).R),
              (fun i => Multiequalizer.ι (Cover.index W.unop P) i ≫ η.app (op i.Y))
                    (MulticospanIndex.fstTo (Cover.index W.unop Q) i) ≫
                  MulticospanIndex.fst (Cover.index W.unop Q) i =
                (fun i => Multiequalizer.ι (Cover.index W.unop P) i ≫ η.app (op i.Y))
                    (MulticospanIndex.sndTo (Cover.index W.unop Q) i) ≫
                  MulticospanIndex.snd (Cover.index W.unop Q) i)) ≫
      (diagramCompIso J F Q X.unop).hom.app W ≫ colimit.ι (diagram J (Q ⋙ F) X.unop) W =
    (diagramCompIso J F P X.unop).hom.app W ≫
      Multiequalizer.lift (Cover.index W.unop (Q ⋙ F)) (multiequalizer (Cover.index W.unop (P ⋙ F)))
          (fun i => Multiequalizer.ι (Cover.index W.unop (P ⋙ F)) i ≫ F.map (η.app (op i.Y)))
          (_ :
            ∀ (i : (Cover.index W.unop (Q ⋙ F)).R),
              (fun i => Multiequalizer.ι (Cover.index W.unop (P ⋙ F)) i ≫ (whiskerRight η F).app (op i.Y))
                    (MulticospanIndex.fstTo (Cover.index W.unop (Q ⋙ F)) i) ≫
                  MulticospanIndex.fst (Cover.index W.unop (Q ⋙ F)) i =
                (fun i => Multiequalizer.ι (Cover.index W.unop (P ⋙ F)) i ≫ (whiskerRight η F).app (op i.Y))
                    (MulticospanIndex.sndTo (Cover.index W.unop (Q ⋙ F)) i) ≫
                  MulticospanIndex.snd (Cover.index W.unop (Q ⋙ F)) i) ≫
        colimit.ι (diagram J (Q ⋙ F) X.unop) W

Next tactic:
simp only [← Category.assoc]
@[reassoc (attr := simp)]
theorem plusCompIso_whiskerRight {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) :
    whiskerRight (J.plusMap η) F ≫ (J.plusCompIso F Q).hom =
      (J.plusCompIso F P).hom ≫ J.plusMap (whiskerRight η F) := by
  ext X
  apply (isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).hom_ext
  intro W
  dsimp [plusObj, plusMap]
  simp only [ι_colimMap, whiskerRight_app, ι_plusCompIso_hom_assoc,
    GrothendieckTopology.diagramNatTrans_app]
  simp only [← Category.assoc, ← F.map_comp]
  dsimp [colimMap, IsColimit.map]
  simp only [colimit.ι_desc]
  dsimp [Cocones.precompose]
  simp only [Functor.map_comp, Category.assoc, ι_plusCompIso_hom]
  simp only [← 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
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
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (Cover J X.unop)ᵒᵖ
⊢ (F.map
          (Multiequalizer.lift (Cover.index W.unop Q) (multiequalizer (Cover.index W.unop P))
            (fun i => Multiequalizer.ι (Cover.index W.unop P) i ≫ η.app (op i.Y))
            (_ :
              ∀ (i : (Cover.index W.unop Q).R),
                (fun i => Multiequalizer.ι (Cover.index W.unop P) i ≫ η.app (op i.Y))
                      (MulticospanIndex.fstTo (Cover.index W.unop Q) i) ≫
                    MulticospanIndex.fst (Cover.index W.unop Q) i =
                  (fun i => Multiequalizer.ι (Cover.index W.unop P) i ≫ η.app (op i.Y))
                      (MulticospanIndex.sndTo (Cover.index W.unop Q) i) ≫
                    MulticospanIndex.snd (Cover.index W.unop Q) i)) ≫
        (diagramCompIso J F Q X.unop).hom.app W) ≫
      colimit.ι (diagram J (Q ⋙ F) X.unop) W =
    ((diagramCompIso J F P X.unop).hom.app W ≫
        Multiequalizer.lift (Cover.index W.unop (Q ⋙ F)) (multiequalizer (Cover.index W.unop (P ⋙ F)))
          (fun i => Multiequalizer.ι (Cover.index W.unop (P ⋙ F)) i ≫ F.map (η.app (op i.Y)))
          (_ :
            ∀ (i : (Cover.index W.unop (Q ⋙ F)).R),
              (fun i => Multiequalizer.ι (Cover.index W.unop (P ⋙ F)) i ≫ (whiskerRight η F).app (op i.Y))
                    (MulticospanIndex.fstTo (Cover.index W.unop (Q ⋙ F)) i) ≫
                  MulticospanIndex.fst (Cover.index W.unop (Q ⋙ F)) i =
                (fun i => Multiequalizer.ι (Cover.index W.unop (P ⋙ F)) i ≫ (whiskerRight η F).app (op i.Y))
                    (MulticospanIndex.sndTo (Cover.index W.unop (Q ⋙ F)) i) ≫
                  MulticospanIndex.snd (Cover.index W.unop (Q ⋙ F)) i)) ≫
      colimit.ι (diagram J (Q ⋙ F) X.unop) W

Next tactic:
congr 1
@[reassoc (attr := simp)]
theorem plusCompIso_whiskerRight {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) :
    whiskerRight (J.plusMap η) F ≫ (J.plusCompIso F Q).hom =
      (J.plusCompIso F P).hom ≫ J.plusMap (whiskerRight η F) := by
  ext X
  apply (isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).hom_ext
  intro W
  dsimp [plusObj, plusMap]
  simp only [ι_colimMap, whiskerRight_app, ι_plusCompIso_hom_assoc,
    GrothendieckTopology.diagramNatTrans_app]
  simp only [← Category.assoc, ← F.map_comp]
  dsimp [colimMap, IsColimit.map]
  simp only [colimit.ι_desc]
  dsimp [Cocones.precompose]
  simp only [Functor.map_comp, Category.assoc, ι_plusCompIso_hom]
  simp only [← Category.assoc]
  congr 1
  -- porting note: this used to work with `ext`
  -- See https://github.com/leanprover-community/mathlib4/issues/5229
  

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
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
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (Cover J X.unop)ᵒᵖ
⊢ F.map
        (Multiequalizer.lift (Cover.index W.unop Q) (multiequalizer (Cover.index W.unop P))
          (fun i => Multiequalizer.ι (Cover.index W.unop P) i ≫ η.app (op i.Y))
          (_ :
            ∀ (i : (Cover.index W.unop Q).R),
              (fun i => Multiequalizer.ι (Cover.index W.unop P) i ≫ η.app (op i.Y))
                    (MulticospanIndex.fstTo (Cover.index W.unop Q) i) ≫
                  MulticospanIndex.fst (Cover.index W.unop Q) i =
                (fun i => Multiequalizer.ι (Cover.index W.unop P) i ≫ η.app (op i.Y))
                    (MulticospanIndex.sndTo (Cover.index W.unop Q) i) ≫
                  MulticospanIndex.snd (Cover.index W.unop Q) i)) ≫
      (diagramCompIso J F Q X.unop).hom.app W =
    (diagramCompIso J F P X.unop).hom.app W ≫
      Multiequalizer.lift (Cover.index W.unop (Q ⋙ F)) (multiequalizer (Cover.index W.unop (P ⋙ F)))
        (fun i => Multiequalizer.ι (Cover.index W.unop (P ⋙ F)) i ≫ F.map (η.app (op i.Y)))
        (_ :
          ∀ (i : (Cover.index W.unop (Q ⋙ F)).R),
            (fun i => Multiequalizer.ι (Cover.index W.unop (P ⋙ F)) i ≫ (whiskerRight η F).app (op i.Y))
                  (MulticospanIndex.fstTo (Cover.index W.unop (Q ⋙ F)) i) ≫
                MulticospanIndex.fst (Cover.index W.unop (Q ⋙ F)) i =
              (fun i => Multiequalizer.ι (Cover.index W.unop (P ⋙ F)) i ≫ (whiskerRight η F).app (op i.Y))
                  (MulticospanIndex.sndTo (Cover.index W.unop (Q ⋙ F)) i) ≫
                MulticospanIndex.snd (Cover.index W.unop (Q ⋙ F)) i)

Next tactic:
apply Multiequalizer.hom_ext
@[reassoc (attr := simp)]
theorem plusCompIso_whiskerRight {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) :
    whiskerRight (J.plusMap η) F ≫ (J.plusCompIso F Q).hom =
      (J.plusCompIso F P).hom ≫ J.plusMap (whiskerRight η F) := by
  ext X
  apply (isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).hom_ext
  intro W
  dsimp [plusObj, plusMap]
  simp only [ι_colimMap, whiskerRight_app, ι_plusCompIso_hom_assoc,
    GrothendieckTopology.diagramNatTrans_app]
  simp only [← Category.assoc, ← F.map_comp]
  dsimp [colimMap, IsColimit.map]
  simp only [colimit.ι_desc]
  dsimp [Cocones.precompose]
  simp only [Functor.map_comp, Category.assoc, ι_plusCompIso_hom]
  simp only [← Category.assoc]
  congr 1
  -- porting note: this used to work with `ext`
  -- See https://github.com/leanprover-community/mathlib4/issues/5229
  apply Multiequalizer.hom_ext
  intro a
  dsimp
  simp only [diagramCompIso_hom_ι_assoc, Multiequalizer.lift_ι, diagramCompIso_hom_ι,
    Category.assoc]
  

Proof state:
case w.h.e_a.h
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
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (Cover J X.unop)ᵒᵖ
a : (Cover.index W.unop (Q ⋙ F)).L
⊢ F.map
        (Multiequalizer.lift (Cover.index W.unop Q) (multiequalizer (Cover.index W.unop P))
          (fun i => Multiequalizer.ι (Cover.index W.unop P) i ≫ η.app (op i.Y))
          (_ :
            ∀ (i : (Cover.index W.unop Q).R),
              (fun i => Multiequalizer.ι (Cover.index W.unop P) i ≫ η.app (op i.Y))
                    (MulticospanIndex.fstTo (Cover.index W.unop Q) i) ≫
                  MulticospanIndex.fst (Cover.index W.unop Q) i =
                (fun i => Multiequalizer.ι (Cover.index W.unop P) i ≫ η.app (op i.Y))
                    (MulticospanIndex.sndTo (Cover.index W.unop Q) i) ≫
                  MulticospanIndex.snd (Cover.index W.unop Q) i)) ≫
      F.map (Multiequalizer.ι (Cover.index W.unop Q) a) =
    F.map (Multiequalizer.ι (Cover.index W.unop P) a) ≫ F.map (η.app (op a.Y))

Next tactic:
simp only [← F.map_comp, Multiequalizer.lift_ι]
@[reassoc (attr := simp)]
theorem whiskerRight_toPlus_comp_plusCompIso_hom :
    whiskerRight (J.toPlus _) _ ≫ (J.plusCompIso F P).hom = J.toPlus _ := 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
⊢ whiskerRight (toPlus J P) F ≫ (plusCompIso J F P).hom = toPlus J (P ⋙ F)

Next tactic:
ext
@[reassoc (attr := simp)]
theorem whiskerRight_toPlus_comp_plusCompIso_hom :
    whiskerRight (J.toPlus _) _ ≫ (J.plusCompIso F P).hom = J.toPlus _ := by
  ext
  

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
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ᵒᵖ
⊢ (whiskerRight (toPlus J P) F ≫ (plusCompIso J F P).hom).app x✝ = (toPlus J (P ⋙ F)).app x✝

Next tactic:
dsimp [toPlus]
@[reassoc (attr := simp)]
theorem whiskerRight_toPlus_comp_plusCompIso_hom :
    whiskerRight (J.toPlus _) _ ≫ (J.plusCompIso F P).hom = J.toPlus _ := by
  ext
  dsimp [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
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ᵒᵖ
⊢ F.map (Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P x✝.unop) (op ⊤)) ≫ (plusCompIso J F P).hom.app x✝ =
    Cover.toMultiequalizer ⊤ (P ⋙ F) ≫ colimit.ι (diagram J (P ⋙ F) x✝.unop) (op ⊤)

Next tactic:
simp only [ι_plusCompIso_hom, Functor.map_comp, Category.assoc]
@[reassoc (attr := simp)]
theorem whiskerRight_toPlus_comp_plusCompIso_hom :
    whiskerRight (J.toPlus _) _ ≫ (J.plusCompIso F P).hom = J.toPlus _ := by
  ext
  dsimp [toPlus]
  simp only [ι_plusCompIso_hom, Functor.map_comp, 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
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ᵒᵖ
⊢ F.map (Cover.toMultiequalizer ⊤ P) ≫
      (diagramCompIso J F P x✝.unop).hom.app (op ⊤) ≫ colimit.ι (diagram J (P ⋙ F) x✝.unop) (op ⊤) =
    Cover.toMultiequalizer ⊤ (P ⋙ F) ≫ colimit.ι (diagram J (P ⋙ F) x✝.unop) (op ⊤)

Next tactic:
simp only [← Category.assoc]
@[reassoc (attr := simp)]
theorem whiskerRight_toPlus_comp_plusCompIso_hom :
    whiskerRight (J.toPlus _) _ ≫ (J.plusCompIso F P).hom = J.toPlus _ := by
  ext
  dsimp [toPlus]
  simp only [ι_plusCompIso_hom, Functor.map_comp, Category.assoc]
  simp only [← 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
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ᵒᵖ
⊢ (F.map (Cover.toMultiequalizer ⊤ P) ≫ (diagramCompIso J F P x✝.unop).hom.app (op ⊤)) ≫
      colimit.ι (diagram J (P ⋙ F) x✝.unop) (op ⊤) =
    Cover.toMultiequalizer ⊤ (P ⋙ F) ≫ colimit.ι (diagram J (P ⋙ F) x✝.unop) (op ⊤)

Next tactic:
congr 1
@[reassoc (attr := simp)]
theorem whiskerRight_toPlus_comp_plusCompIso_hom :
    whiskerRight (J.toPlus _) _ ≫ (J.plusCompIso F P).hom = J.toPlus _ := by
  ext
  dsimp [toPlus]
  simp only [ι_plusCompIso_hom, Functor.map_comp, Category.assoc]
  simp only [← Category.assoc]
  congr 1
  -- porting note: this used to work with `ext`
  -- See https://github.com/leanprover-community/mathlib4/issues/5229
  

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
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ᵒᵖ
⊢ F.map (Cover.toMultiequalizer ⊤ P) ≫ (diagramCompIso J F P x✝.unop).hom.app (op ⊤) = Cover.toMultiequalizer ⊤ (P ⋙ F)

Next tactic:
apply Multiequalizer.hom_ext
@[reassoc (attr := simp)]
theorem whiskerRight_toPlus_comp_plusCompIso_hom :
    whiskerRight (J.toPlus _) _ ≫ (J.plusCompIso F P).hom = J.toPlus _ := by
  ext
  dsimp [toPlus]
  simp only [ι_plusCompIso_hom, Functor.map_comp, Category.assoc]
  simp only [← Category.assoc]
  congr 1
  -- porting note: this used to work with `ext`
  -- See https://github.com/leanprover-community/mathlib4/issues/5229
  apply Multiequalizer.hom_ext
  

Proof state:
case w.h.e_a.h
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ᵒᵖ
⊢ ∀ (a : (Cover.index (op ⊤).unop (P ⋙ F)).L),
    (F.map (Cover.toMultiequalizer ⊤ P) ≫ (diagramCompIso J F P x✝.unop).hom.app (op ⊤)) ≫
        Multiequalizer.ι (Cover.index (op ⊤).unop (P ⋙ F)) a =
      Cover.toMultiequalizer ⊤ (P ⋙ F) ≫ Multiequalizer.ι (Cover.index (op ⊤).unop (P ⋙ F)) a

Next tactic:
delta Cover.toMultiequalizer