Theorem: CategoryTheory.GrothendieckTopology.plusCompIso_whiskerRight
File: Mathlib/CategoryTheory/Sites/CompatiblePlus.lean

tactic: ext X
state_before: 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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
⊢ whiskerRight (J.plusMap η) F ≫ (J.plusCompIso F Q).hom = (J.plusCompIso F P).hom ≫ J.plusMap (whiskerRight η F)
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
⊢ (whiskerRight (J.plusMap η) F ≫ (J.plusCompIso F Q).hom).app X =
    ((J.plusCompIso F P).hom ≫ J.plusMap (whiskerRight η F)).app X

tactic: apply (isColimitOfPreserves F (colimit.isColimit (J.diagram P X.unop))).hom_ext
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
⊢ (whiskerRight (J.plusMap η) F ≫ (J.plusCompIso F Q).hom).app X =
    ((J.plusCompIso F P).hom ≫ J.plusMap (whiskerRight η F)).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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
⊢ ∀ (j : (J.Cover X.unop)ᵒᵖ),
    (F.mapCocone (colimit.cocone (J.diagram P X.unop))).ι.app j ≫
        (whiskerRight (J.plusMap η) F ≫ (J.plusCompIso F Q).hom).app X =
      (F.mapCocone (colimit.cocone (J.diagram P X.unop))).ι.app j ≫
        ((J.plusCompIso F P).hom ≫ J.plusMap (whiskerRight η F)).app X

tactic: intro W
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
⊢ ∀ (j : (J.Cover X.unop)ᵒᵖ),
    (F.mapCocone (colimit.cocone (J.diagram P X.unop))).ι.app j ≫
        (whiskerRight (J.plusMap η) F ≫ (J.plusCompIso F Q).hom).app X =
      (F.mapCocone (colimit.cocone (J.diagram P X.unop))).ι.app j ≫
        ((J.plusCompIso F P).hom ≫ J.plusMap (whiskerRight η F)).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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ (F.mapCocone (colimit.cocone (J.diagram P X.unop))).ι.app W ≫
      (whiskerRight (J.plusMap η) F ≫ (J.plusCompIso F Q).hom).app X =
    (F.mapCocone (colimit.cocone (J.diagram P X.unop))).ι.app W ≫
      ((J.plusCompIso F P).hom ≫ J.plusMap (whiskerRight η F)).app X

tactic: dsimp [plusObj, plusMap]
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ (F.mapCocone (colimit.cocone (J.diagram P X.unop))).ι.app W ≫
      (whiskerRight (J.plusMap η) F ≫ (J.plusCompIso F Q).hom).app X =
    (F.mapCocone (colimit.cocone (J.diagram P X.unop))).ι.app W ≫
      ((J.plusCompIso F P).hom ≫ J.plusMap (whiskerRight η F)).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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ F.map (colimit.ι (J.diagram P X.unop) W) ≫
      F.map (colimMap (J.diagramNatTrans η X.unop)) ≫ (J.plusCompIso F Q).hom.app X =
    F.map (colimit.ι (J.diagram P X.unop) W) ≫
      (J.plusCompIso F P).hom.app X ≫ colimMap (J.diagramNatTrans (whiskerRight η F) X.unop)

tactic: simp only [ι_colimMap, whiskerRight_app, ι_plusCompIso_hom_assoc,
  GrothendieckTopology.diagramNatTrans_app]
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ F.map (colimit.ι (J.diagram P X.unop) W) ≫
      F.map (colimMap (J.diagramNatTrans η X.unop)) ≫ (J.plusCompIso F Q).hom.app X =
    F.map (colimit.ι (J.diagram P X.unop) W) ≫
      (J.plusCompIso F P).hom.app X ≫ colimMap (J.diagramNatTrans (whiskerRight η F) X.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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ F.map (colimit.ι (J.diagram P X.unop) W) ≫
      F.map (colimMap (J.diagramNatTrans η X.unop)) ≫ (J.plusCompIso F Q).hom.app X =
    (J.diagramCompIso F P X.unop).hom.app W ≫
      Multiequalizer.lift (W.unop.index (Q ⋙ F)) ((J.diagram (P ⋙ F) X.unop).obj W)
          (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯ ≫
        colimit.ι (J.diagram (Q ⋙ F) X.unop) W

tactic: simp only [← Category.assoc, ← F.map_comp]
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ F.map (colimit.ι (J.diagram P X.unop) W) ≫
      F.map (colimMap (J.diagramNatTrans η X.unop)) ≫ (J.plusCompIso F Q).hom.app X =
    (J.diagramCompIso F P X.unop).hom.app W ≫
      Multiequalizer.lift (W.unop.index (Q ⋙ F)) ((J.diagram (P ⋙ F) X.unop).obj W)
          (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯ ≫
        colimit.ι (J.diagram (Q ⋙ F) X.unop) W
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ F.map (colimit.ι (J.diagram P X.unop) W ≫ colimMap (J.diagramNatTrans η X.unop)) ≫ (J.plusCompIso F Q).hom.app X =
    ((J.diagramCompIso F P X.unop).hom.app W ≫
        Multiequalizer.lift (W.unop.index (Q ⋙ F)) ((J.diagram (P ⋙ F) X.unop).obj W)
          (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯) ≫
      colimit.ι (J.diagram (Q ⋙ F) X.unop) W

tactic: dsimp [colimMap, IsColimit.map]
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ F.map (colimit.ι (J.diagram P X.unop) W ≫ colimMap (J.diagramNatTrans η X.unop)) ≫ (J.plusCompIso F Q).hom.app X =
    ((J.diagramCompIso F P X.unop).hom.app W ≫
        Multiequalizer.lift (W.unop.index (Q ⋙ F)) ((J.diagram (P ⋙ F) X.unop).obj W)
          (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯) ≫
      colimit.ι (J.diagram (Q ⋙ F) X.unop) W
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ F.map
        (colimit.ι (J.diagram P X.unop) W ≫
          colimit.desc (J.diagram P X.unop)
            ((Cocones.precompose (J.diagramNatTrans η X.unop)).obj (colimit.cocone (J.diagram Q X.unop)))) ≫
      (J.plusCompIso F Q).hom.app X =
    ((J.diagramCompIso F P X.unop).hom.app W ≫
        Multiequalizer.lift (W.unop.index (Q ⋙ F)) (multiequalizer (W.unop.index (P ⋙ F)))
          (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯) ≫
      colimit.ι (J.diagram (Q ⋙ F) X.unop) W

tactic: simp only [colimit.ι_desc]
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ F.map
        (colimit.ι (J.diagram P X.unop) W ≫
          colimit.desc (J.diagram P X.unop)
            ((Cocones.precompose (J.diagramNatTrans η X.unop)).obj (colimit.cocone (J.diagram Q X.unop)))) ≫
      (J.plusCompIso F Q).hom.app X =
    ((J.diagramCompIso F P X.unop).hom.app W ≫
        Multiequalizer.lift (W.unop.index (Q ⋙ F)) (multiequalizer (W.unop.index (P ⋙ F)))
          (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯) ≫
      colimit.ι (J.diagram (Q ⋙ F) X.unop) W
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ F.map (((Cocones.precompose (J.diagramNatTrans η X.unop)).obj (colimit.cocone (J.diagram Q X.unop))).ι.app W) ≫
      (J.plusCompIso F Q).hom.app X =
    ((J.diagramCompIso F P X.unop).hom.app W ≫
        Multiequalizer.lift (W.unop.index (Q ⋙ F)) (multiequalizer (W.unop.index (P ⋙ F)))
          (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯) ≫
      colimit.ι (J.diagram (Q ⋙ F) X.unop) W

tactic: dsimp [Cocones.precompose]
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ F.map (((Cocones.precompose (J.diagramNatTrans η X.unop)).obj (colimit.cocone (J.diagram Q X.unop))).ι.app W) ≫
      (J.plusCompIso F Q).hom.app X =
    ((J.diagramCompIso F P X.unop).hom.app W ≫
        Multiequalizer.lift (W.unop.index (Q ⋙ F)) (multiequalizer (W.unop.index (P ⋙ F)))
          (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯) ≫
      colimit.ι (J.diagram (Q ⋙ F) X.unop) W
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ F.map
        (Multiequalizer.lift (W.unop.index Q) (multiequalizer (W.unop.index P))
            (fun i => Multiequalizer.ι (W.unop.index P) i ≫ η.app { unop := i.Y }) ⋯ ≫
          colimit.ι (J.diagram Q X.unop) W) ≫
      (J.plusCompIso F Q).hom.app X =
    ((J.diagramCompIso F P X.unop).hom.app W ≫
        Multiequalizer.lift (W.unop.index (Q ⋙ F)) (multiequalizer (W.unop.index (P ⋙ F)))
          (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯) ≫
      colimit.ι (J.diagram (Q ⋙ F) X.unop) W

tactic: simp only [Functor.map_comp, Category.assoc, ι_plusCompIso_hom]
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ F.map
        (Multiequalizer.lift (W.unop.index Q) (multiequalizer (W.unop.index P))
            (fun i => Multiequalizer.ι (W.unop.index P) i ≫ η.app { unop := i.Y }) ⋯ ≫
          colimit.ι (J.diagram Q X.unop) W) ≫
      (J.plusCompIso F Q).hom.app X =
    ((J.diagramCompIso F P X.unop).hom.app W ≫
        Multiequalizer.lift (W.unop.index (Q ⋙ F)) (multiequalizer (W.unop.index (P ⋙ F)))
          (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯) ≫
      colimit.ι (J.diagram (Q ⋙ F) X.unop) W
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ F.map
        (Multiequalizer.lift (W.unop.index Q) (multiequalizer (W.unop.index P))
          (fun i => Multiequalizer.ι (W.unop.index P) i ≫ η.app { unop := i.Y }) ⋯) ≫
      (J.diagramCompIso F Q X.unop).hom.app W ≫ colimit.ι (J.diagram (Q ⋙ F) X.unop) W =
    (J.diagramCompIso F P X.unop).hom.app W ≫
      Multiequalizer.lift (W.unop.index (Q ⋙ F)) (multiequalizer (W.unop.index (P ⋙ F)))
          (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯ ≫
        colimit.ι (J.diagram (Q ⋙ F) X.unop) W

tactic: simp only [← 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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ F.map
        (Multiequalizer.lift (W.unop.index Q) (multiequalizer (W.unop.index P))
          (fun i => Multiequalizer.ι (W.unop.index P) i ≫ η.app { unop := i.Y }) ⋯) ≫
      (J.diagramCompIso F Q X.unop).hom.app W ≫ colimit.ι (J.diagram (Q ⋙ F) X.unop) W =
    (J.diagramCompIso F P X.unop).hom.app W ≫
      Multiequalizer.lift (W.unop.index (Q ⋙ F)) (multiequalizer (W.unop.index (P ⋙ F)))
          (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯ ≫
        colimit.ι (J.diagram (Q ⋙ F) X.unop) W
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ (F.map
          (Multiequalizer.lift (W.unop.index Q) (multiequalizer (W.unop.index P))
            (fun i => Multiequalizer.ι (W.unop.index P) i ≫ η.app { unop := i.Y }) ⋯) ≫
        (J.diagramCompIso F Q X.unop).hom.app W) ≫
      colimit.ι (J.diagram (Q ⋙ F) X.unop) W =
    ((J.diagramCompIso F P X.unop).hom.app W ≫
        Multiequalizer.lift (W.unop.index (Q ⋙ F)) (multiequalizer (W.unop.index (P ⋙ F)))
          (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯) ≫
      colimit.ι (J.diagram (Q ⋙ F) X.unop) W

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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ (F.map
          (Multiequalizer.lift (W.unop.index Q) (multiequalizer (W.unop.index P))
            (fun i => Multiequalizer.ι (W.unop.index P) i ≫ η.app { unop := i.Y }) ⋯) ≫
        (J.diagramCompIso F Q X.unop).hom.app W) ≫
      colimit.ι (J.diagram (Q ⋙ F) X.unop) W =
    ((J.diagramCompIso F P X.unop).hom.app W ≫
        Multiequalizer.lift (W.unop.index (Q ⋙ F)) (multiequalizer (W.unop.index (P ⋙ F)))
          (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯) ≫
      colimit.ι (J.diagram (Q ⋙ F) X.unop) W
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ F.map
        (Multiequalizer.lift (W.unop.index Q) (multiequalizer (W.unop.index P))
          (fun i => Multiequalizer.ι (W.unop.index P) i ≫ η.app { unop := i.Y }) ⋯) ≫
      (J.diagramCompIso F Q X.unop).hom.app W =
    (J.diagramCompIso F P X.unop).hom.app W ≫
      Multiequalizer.lift (W.unop.index (Q ⋙ F)) (multiequalizer (W.unop.index (P ⋙ F)))
        (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯

tactic: apply Multiequalizer.hom_ext
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
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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ F.map
        (Multiequalizer.lift (W.unop.index Q) (multiequalizer (W.unop.index P))
          (fun i => Multiequalizer.ι (W.unop.index P) i ≫ η.app { unop := i.Y }) ⋯) ≫
      (J.diagramCompIso F Q X.unop).hom.app W =
    (J.diagramCompIso F P X.unop).hom.app W ≫
      Multiequalizer.lift (W.unop.index (Q ⋙ F)) (multiequalizer (W.unop.index (P ⋙ F)))
        (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯
state_after: 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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ ∀ (a : (W.unop.index (Q ⋙ F)).L),
    (F.map
            (Multiequalizer.lift (W.unop.index Q) (multiequalizer (W.unop.index P))
              (fun i => Multiequalizer.ι (W.unop.index P) i ≫ η.app { unop := i.Y }) ⋯) ≫
          (J.diagramCompIso F Q X.unop).hom.app W) ≫
        Multiequalizer.ι (W.unop.index (Q ⋙ F)) a =
      ((J.diagramCompIso F P X.unop).hom.app W ≫
          Multiequalizer.lift (W.unop.index (Q ⋙ F)) (multiequalizer (W.unop.index (P ⋙ F)))
            (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯) ≫
        Multiequalizer.ι (W.unop.index (Q ⋙ F)) a

tactic: intro a
state_before: 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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
⊢ ∀ (a : (W.unop.index (Q ⋙ F)).L),
    (F.map
            (Multiequalizer.lift (W.unop.index Q) (multiequalizer (W.unop.index P))
              (fun i => Multiequalizer.ι (W.unop.index P) i ≫ η.app { unop := i.Y }) ⋯) ≫
          (J.diagramCompIso F Q X.unop).hom.app W) ≫
        Multiequalizer.ι (W.unop.index (Q ⋙ F)) a =
      ((J.diagramCompIso F P X.unop).hom.app W ≫
          Multiequalizer.lift (W.unop.index (Q ⋙ F)) (multiequalizer (W.unop.index (P ⋙ F)))
            (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯) ≫
        Multiequalizer.ι (W.unop.index (Q ⋙ F)) a
state_after: 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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
a : (W.unop.index (Q ⋙ F)).L
⊢ (F.map
          (Multiequalizer.lift (W.unop.index Q) (multiequalizer (W.unop.index P))
            (fun i => Multiequalizer.ι (W.unop.index P) i ≫ η.app { unop := i.Y }) ⋯) ≫
        (J.diagramCompIso F Q X.unop).hom.app W) ≫
      Multiequalizer.ι (W.unop.index (Q ⋙ F)) a =
    ((J.diagramCompIso F P X.unop).hom.app W ≫
        Multiequalizer.lift (W.unop.index (Q ⋙ F)) (multiequalizer (W.unop.index (P ⋙ F)))
          (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯) ≫
      Multiequalizer.ι (W.unop.index (Q ⋙ F)) a

tactic: simp only [diagramCompIso_hom_ι_assoc, Multiequalizer.lift_ι, diagramCompIso_hom_ι,
  Category.assoc]
state_before: 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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
a : (W.unop.index (Q ⋙ F)).L
⊢ (F.map
          (Multiequalizer.lift (W.unop.index Q) (multiequalizer (W.unop.index P))
            (fun i => Multiequalizer.ι (W.unop.index P) i ≫ η.app { unop := i.Y }) ⋯) ≫
        (J.diagramCompIso F Q X.unop).hom.app W) ≫
      Multiequalizer.ι (W.unop.index (Q ⋙ F)) a =
    ((J.diagramCompIso F P X.unop).hom.app W ≫
        Multiequalizer.lift (W.unop.index (Q ⋙ F)) (multiequalizer (W.unop.index (P ⋙ F)))
          (fun i => Multiequalizer.ι (W.unop.index (P ⋙ F)) i ≫ F.map (η.app { unop := i.Y })) ⋯) ≫
      Multiequalizer.ι (W.unop.index (Q ⋙ F)) a
state_after: 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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
a : (W.unop.index (Q ⋙ F)).L
⊢ F.map
        (Multiequalizer.lift (W.unop.index Q) (multiequalizer (W.unop.index P))
          (fun i => Multiequalizer.ι (W.unop.index P) i ≫ η.app { unop := i.Y }) ⋯) ≫
      F.map (Multiequalizer.ι (W.unop.index Q) a) =
    F.map (Multiequalizer.ι (W.unop.index P) a) ≫ F.map (η.app { unop := a.Y })

tactic: simp only [← F.map_comp, Multiequalizer.lift_ι]
state_before: 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 : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P✝ : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : Cᵒᵖ
W : (J.Cover X.unop)ᵒᵖ
a : (W.unop.index (Q ⋙ F)).L
⊢ F.map
        (Multiequalizer.lift (W.unop.index Q) (multiequalizer (W.unop.index P))
          (fun i => Multiequalizer.ι (W.unop.index P) i ≫ η.app { unop := i.Y }) ⋯) ≫
      F.map (Multiequalizer.ι (W.unop.index Q) a) =
    F.map (Multiequalizer.ι (W.unop.index P) a) ≫ F.map (η.app { unop := a.Y })
state_after: no goals