Theorem: CategoryTheory.GrothendieckTopology.liftToPlusObjLimitObj_fac
File: Mathlib/CategoryTheory/Sites/LeftExact.lean

tactic: dsimp only [liftToPlusObjLimitObj]
state_before: 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
⊢ liftToPlusObjLimitObj F X S ≫ (J.plusMap (limit.π F k)).app { unop := X } = S.π.app k
state_after: 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
⊢ (limit.lift (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X }) S ≫
        (HasLimit.isoOfNatIso
              (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                  ⋯).symm).hom ≫
          (colimitLimitIso (F ⋙ J.diagramFunctor D X)).inv ≫
            (HasColimit.isoOfNatIso
                ((isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
                  (limit.isLimit (F ⋙ J.diagramFunctor D X)))).inv) ≫
      (J.plusMap (limit.π F k)).app { unop := X } =
    S.π.app k

tactic: rw [← (limit.isLimit (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X))).fac S k,
  Category.assoc]
state_before: 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
⊢ (limit.lift (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X }) S ≫
        (HasLimit.isoOfNatIso
              (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                  ⋯).symm).hom ≫
          (colimitLimitIso (F ⋙ J.diagramFunctor D X)).inv ≫
            (HasColimit.isoOfNatIso
                ((isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
                  (limit.isLimit (F ⋙ J.diagramFunctor D X)))).inv) ≫
      (J.plusMap (limit.π F k)).app { unop := X } =
    S.π.app k
state_after: 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
⊢ limit.lift (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X }) S ≫
      ((HasLimit.isoOfNatIso
              (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                  ⋯).symm).hom ≫
          (colimitLimitIso (F ⋙ J.diagramFunctor D X)).inv ≫
            (HasColimit.isoOfNatIso
                ((isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
                  (limit.isLimit (F ⋙ J.diagramFunctor D X)))).inv) ≫
        (J.plusMap (limit.π F k)).app { unop := X } =
    (limit.isLimit (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })).lift S ≫
      (limit.cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })).π.app k

tactic: congr 1
state_before: 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
⊢ limit.lift (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X }) S ≫
      ((HasLimit.isoOfNatIso
              (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                  ⋯).symm).hom ≫
          (colimitLimitIso (F ⋙ J.diagramFunctor D X)).inv ≫
            (HasColimit.isoOfNatIso
                ((isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
                  (limit.isLimit (F ⋙ J.diagramFunctor D X)))).inv) ≫
        (J.plusMap (limit.π F k)).app { unop := X } =
    (limit.isLimit (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })).lift S ≫
      (limit.cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })).π.app k
state_after: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
⊢ ((HasLimit.isoOfNatIso
            (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                ⋯).symm).hom ≫
        (colimitLimitIso (F ⋙ J.diagramFunctor D X)).inv ≫
          (HasColimit.isoOfNatIso
              ((isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
                (limit.isLimit (F ⋙ J.diagramFunctor D X)))).inv) ≫
      (J.plusMap (limit.π F k)).app { unop := X } =
    (limit.cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })).π.app k

tactic: dsimp
state_before: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
⊢ ((HasLimit.isoOfNatIso
            (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                ⋯).symm).hom ≫
        (colimitLimitIso (F ⋙ J.diagramFunctor D X)).inv ≫
          (HasColimit.isoOfNatIso
              ((isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
                (limit.isLimit (F ⋙ J.diagramFunctor D X)))).inv) ≫
      (J.plusMap (limit.π F k)).app { unop := X } =
    (limit.cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })).π.app k
state_after: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
⊢ ((HasLimit.isoOfNatIso
            (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                ⋯).symm).hom ≫
        (colimitLimitIso (F ⋙ J.diagramFunctor D X)).inv ≫
          (HasColimit.isoOfNatIso
              ((isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
                (limit.isLimit (F ⋙ J.diagramFunctor D X)))).inv) ≫
      (J.plusMap (limit.π F k)).app { unop := X } =
    limit.π (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X }) k

tactic: rw [Category.assoc, Category.assoc, ← Iso.eq_inv_comp, Iso.inv_comp_eq, Iso.inv_comp_eq]
state_before: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
⊢ ((HasLimit.isoOfNatIso
            (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                ⋯).symm).hom ≫
        (colimitLimitIso (F ⋙ J.diagramFunctor D X)).inv ≫
          (HasColimit.isoOfNatIso
              ((isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
                (limit.isLimit (F ⋙ J.diagramFunctor D X)))).inv) ≫
      (J.plusMap (limit.π F k)).app { unop := X } =
    limit.π (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X }) k
state_after: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
⊢ (J.plusMap (limit.π F k)).app { unop := X } =
    (HasColimit.isoOfNatIso
          ((isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
            (limit.isLimit (F ⋙ J.diagramFunctor D X)))).hom ≫
      (colimitLimitIso (F ⋙ J.diagramFunctor D X)).hom ≫
        (HasLimit.isoOfNatIso
              (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                  ⋯).symm).inv ≫
          limit.π (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X }) k

tactic: refine colimit.hom_ext (fun j => ?_)
state_before: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
⊢ (J.plusMap (limit.π F k)).app { unop := X } =
    (HasColimit.isoOfNatIso
          ((isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
            (limit.isLimit (F ⋙ J.diagramFunctor D X)))).hom ≫
      (colimitLimitIso (F ⋙ J.diagramFunctor D X)).hom ≫
        (HasLimit.isoOfNatIso
              (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                  ⋯).symm).inv ≫
          limit.π (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X }) k
state_after: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ colimit.ι (J.diagram (limit F) { unop := X }.unop) j ≫ (J.plusMap (limit.π F k)).app { unop := X } =
    colimit.ι (J.diagram (limit F) { unop := X }.unop) j ≫
      (HasColimit.isoOfNatIso
            ((isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
              (limit.isLimit (F ⋙ J.diagramFunctor D X)))).hom ≫
        (colimitLimitIso (F ⋙ J.diagramFunctor D X)).hom ≫
          (HasLimit.isoOfNatIso
                (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                    ⋯).symm).inv ≫
            limit.π (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X }) k

tactic: dsimp [plusMap]
state_before: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ colimit.ι (J.diagram (limit F) { unop := X }.unop) j ≫ (J.plusMap (limit.π F k)).app { unop := X } =
    colimit.ι (J.diagram (limit F) { unop := X }.unop) j ≫
      (HasColimit.isoOfNatIso
            ((isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
              (limit.isLimit (F ⋙ J.diagramFunctor D X)))).hom ≫
        (colimitLimitIso (F ⋙ J.diagramFunctor D X)).hom ≫
          (HasLimit.isoOfNatIso
                (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                    ⋯).symm).inv ≫
            limit.π (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X }) k
state_after: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ colimit.ι (J.diagram (limit F) X) j ≫ colimMap (J.diagramNatTrans (limit.π F k) X) =
    colimit.ι (J.diagram (limit F) X) j ≫
      (HasColimit.isoOfNatIso
            ((isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
              (limit.isLimit (F ⋙ J.diagramFunctor D X)))).hom ≫
        (colimitLimitIso (F ⋙ J.diagramFunctor D X)).hom ≫
          (HasLimit.isoOfNatIso
                (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                    ⋯).symm).inv ≫
            limit.π (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X }) k

tactic: simp only [HasColimit.isoOfNatIso_ι_hom_assoc, ι_colimMap]
state_before: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ colimit.ι (J.diagram (limit F) X) j ≫ colimMap (J.diagramNatTrans (limit.π F k) X) =
    colimit.ι (J.diagram (limit F) X) j ≫
      (HasColimit.isoOfNatIso
            ((isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
              (limit.isLimit (F ⋙ J.diagramFunctor D X)))).hom ≫
        (colimitLimitIso (F ⋙ J.diagramFunctor D X)).hom ≫
          (HasLimit.isoOfNatIso
                (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                    ⋯).symm).inv ≫
            limit.π (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X }) k
state_after: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ (J.diagramNatTrans (limit.π F k) X).app j ≫ colimit.ι (J.diagram (F.obj k) X) j =
    ((isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
              (limit.isLimit (F ⋙ J.diagramFunctor D X))).hom.app
        j ≫
      colimit.ι (limit (F ⋙ J.diagramFunctor D X)) j ≫
        (colimitLimitIso (F ⋙ J.diagramFunctor D X)).hom ≫
          (HasLimit.isoOfNatIso
                (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                    ⋯).symm).inv ≫
            limit.π (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X }) k

tactic: dsimp [IsLimit.conePointUniqueUpToIso, HasLimit.isoOfNatIso, IsLimit.map]
state_before: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ (J.diagramNatTrans (limit.π F k) X).app j ≫ colimit.ι (J.diagram (F.obj k) X) j =
    ((isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
              (limit.isLimit (F ⋙ J.diagramFunctor D X))).hom.app
        j ≫
      colimit.ι (limit (F ⋙ J.diagramFunctor D X)) j ≫
        (colimitLimitIso (F ⋙ J.diagramFunctor D X)).hom ≫
          (HasLimit.isoOfNatIso
                (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                    ⋯).symm).inv ≫
            limit.π (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X }) k
state_after: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ Multiequalizer.lift (j.unop.index (F.obj k)) (multiequalizer (j.unop.index (limit F)))
        (fun i => Multiequalizer.ι (j.unop.index (limit F)) i ≫ (limit.π F k).app { unop := i.Y }) ⋯ ≫
      colimit.ι (J.diagram (F.obj k) X) j =
    (limit.lift (F ⋙ J.diagramFunctor D X) ((J.diagramFunctor D X).mapCone (limit.cone F))).app j ≫
      colimit.ι (limit (F ⋙ J.diagramFunctor D X)) j ≫
        (colimitLimitIso (F ⋙ J.diagramFunctor D X)).hom ≫
          limit.lift (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
              ((Cones.postcompose
                    (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                        ⋯).hom).obj
                (limit.cone (colimit (F ⋙ J.diagramFunctor D X).flip))) ≫
            limit.π (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X }) k

tactic: rw [limit.lift_π]
state_before: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ Multiequalizer.lift (j.unop.index (F.obj k)) (multiequalizer (j.unop.index (limit F)))
        (fun i => Multiequalizer.ι (j.unop.index (limit F)) i ≫ (limit.π F k).app { unop := i.Y }) ⋯ ≫
      colimit.ι (J.diagram (F.obj k) X) j =
    (limit.lift (F ⋙ J.diagramFunctor D X) ((J.diagramFunctor D X).mapCone (limit.cone F))).app j ≫
      colimit.ι (limit (F ⋙ J.diagramFunctor D X)) j ≫
        (colimitLimitIso (F ⋙ J.diagramFunctor D X)).hom ≫
          limit.lift (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
              ((Cones.postcompose
                    (NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k)
                        ⋯).hom).obj
                (limit.cone (colimit (F ⋙ J.diagramFunctor D X).flip))) ≫
            limit.π (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X }) k
state_after: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ Multiequalizer.lift (j.unop.index (F.obj k)) (multiequalizer (j.unop.index (limit F)))
        (fun i => Multiequalizer.ι (j.unop.index (limit F)) i ≫ (limit.π F k).app { unop := i.Y }) ⋯ ≫
      colimit.ι (J.diagram (F.obj k) X) j =
    (limit.lift (F ⋙ J.diagramFunctor D X) ((J.diagramFunctor D X).mapCone (limit.cone F))).app j ≫
      colimit.ι (limit (F ⋙ J.diagramFunctor D X)) j ≫
        (colimitLimitIso (F ⋙ J.diagramFunctor D X)).hom ≫
          ((Cones.postcompose
                      (NatIso.ofComponents
                          (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k) ⋯).hom).obj
                  (limit.cone (colimit (F ⋙ J.diagramFunctor D X).flip))).π.app
            k

tactic: dsimp
state_before: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ Multiequalizer.lift (j.unop.index (F.obj k)) (multiequalizer (j.unop.index (limit F)))
        (fun i => Multiequalizer.ι (j.unop.index (limit F)) i ≫ (limit.π F k).app { unop := i.Y }) ⋯ ≫
      colimit.ι (J.diagram (F.obj k) X) j =
    (limit.lift (F ⋙ J.diagramFunctor D X) ((J.diagramFunctor D X).mapCone (limit.cone F))).app j ≫
      colimit.ι (limit (F ⋙ J.diagramFunctor D X)) j ≫
        (colimitLimitIso (F ⋙ J.diagramFunctor D X)).hom ≫
          ((Cones.postcompose
                      (NatIso.ofComponents
                          (fun k => colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k) ⋯).hom).obj
                  (limit.cone (colimit (F ⋙ J.diagramFunctor D X).flip))).π.app
            k
state_after: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ Multiequalizer.lift (j.unop.index (F.obj k)) (multiequalizer (j.unop.index (limit F)))
        (fun i => Multiequalizer.ι (j.unop.index (limit F)) i ≫ (limit.π F k).app { unop := i.Y }) ⋯ ≫
      colimit.ι (J.diagram (F.obj k) X) j =
    (limit.lift (F ⋙ J.diagramFunctor D X) ((J.diagramFunctor D X).mapCone (limit.cone F))).app j ≫
      colimit.ι (limit (F ⋙ J.diagramFunctor D X)) j ≫
        (colimitLimitIso (F ⋙ J.diagramFunctor D X)).hom ≫
          limit.π (colimit (F ⋙ J.diagramFunctor D X).flip) k ≫
            (colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k).hom

tactic: rw [ι_colimitLimitIso_limit_π_assoc]
state_before: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ Multiequalizer.lift (j.unop.index (F.obj k)) (multiequalizer (j.unop.index (limit F)))
        (fun i => Multiequalizer.ι (j.unop.index (limit F)) i ≫ (limit.π F k).app { unop := i.Y }) ⋯ ≫
      colimit.ι (J.diagram (F.obj k) X) j =
    (limit.lift (F ⋙ J.diagramFunctor D X) ((J.diagramFunctor D X).mapCone (limit.cone F))).app j ≫
      colimit.ι (limit (F ⋙ J.diagramFunctor D X)) j ≫
        (colimitLimitIso (F ⋙ J.diagramFunctor D X)).hom ≫
          limit.π (colimit (F ⋙ J.diagramFunctor D X).flip) k ≫
            (colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k).hom
state_after: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ Multiequalizer.lift (j.unop.index (F.obj k)) (multiequalizer (j.unop.index (limit F)))
        (fun i => Multiequalizer.ι (j.unop.index (limit F)) i ≫ (limit.π F k).app { unop := i.Y }) ⋯ ≫
      colimit.ι (J.diagram (F.obj k) X) j =
    (limit.lift (F ⋙ J.diagramFunctor D X) ((J.diagramFunctor D X).mapCone (limit.cone F))).app j ≫
      (limit.π (F ⋙ J.diagramFunctor D X) k).app j ≫
        (colimit.ι (F ⋙ J.diagramFunctor D X).flip j).app k ≫
          (colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k).hom

tactic: simp_rw [← Category.assoc, ← NatTrans.comp_app]
state_before: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ Multiequalizer.lift (j.unop.index (F.obj k)) (multiequalizer (j.unop.index (limit F)))
        (fun i => Multiequalizer.ι (j.unop.index (limit F)) i ≫ (limit.π F k).app { unop := i.Y }) ⋯ ≫
      colimit.ι (J.diagram (F.obj k) X) j =
    (limit.lift (F ⋙ J.diagramFunctor D X) ((J.diagramFunctor D X).mapCone (limit.cone F))).app j ≫
      (limit.π (F ⋙ J.diagramFunctor D X) k).app j ≫
        (colimit.ι (F ⋙ J.diagramFunctor D X).flip j).app k ≫
          (colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k).hom
state_after: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ Multiequalizer.lift (j.unop.index (F.obj k)) (multiequalizer (j.unop.index (limit F)))
        (fun i => Multiequalizer.ι (j.unop.index (limit F)) i ≫ (limit.π F k).app { unop := i.Y }) ⋯ ≫
      colimit.ι (J.diagram (F.obj k) X) j =
    ((limit.lift (F ⋙ J.diagramFunctor D X) ((J.diagramFunctor D X).mapCone (limit.cone F)) ≫
              limit.π (F ⋙ J.diagramFunctor D X) k).app
          j ≫
        (colimit.ι (F ⋙ J.diagramFunctor D X).flip j).app k) ≫
      (colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k).hom

tactic: rw [limit.lift_π, Category.assoc]
state_before: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ Multiequalizer.lift (j.unop.index (F.obj k)) (multiequalizer (j.unop.index (limit F)))
        (fun i => Multiequalizer.ι (j.unop.index (limit F)) i ≫ (limit.π F k).app { unop := i.Y }) ⋯ ≫
      colimit.ι (J.diagram (F.obj k) X) j =
    ((limit.lift (F ⋙ J.diagramFunctor D X) ((J.diagramFunctor D X).mapCone (limit.cone F)) ≫
              limit.π (F ⋙ J.diagramFunctor D X) k).app
          j ≫
        (colimit.ι (F ⋙ J.diagramFunctor D X).flip j).app k) ≫
      (colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k).hom
state_after: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ Multiequalizer.lift (j.unop.index (F.obj k)) (multiequalizer (j.unop.index (limit F)))
        (fun i => Multiequalizer.ι (j.unop.index (limit F)) i ≫ (limit.π F k).app { unop := i.Y }) ⋯ ≫
      colimit.ι (J.diagram (F.obj k) X) j =
    (((J.diagramFunctor D X).mapCone (limit.cone F)).π.app k).app j ≫
      (colimit.ι (F ⋙ J.diagramFunctor D X).flip j).app k ≫
        (colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k).hom

tactic: congr 1
state_before: case 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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ Multiequalizer.lift (j.unop.index (F.obj k)) (multiequalizer (j.unop.index (limit F)))
        (fun i => Multiequalizer.ι (j.unop.index (limit F)) i ≫ (limit.π F k).app { unop := i.Y }) ⋯ ≫
      colimit.ι (J.diagram (F.obj k) X) j =
    (((J.diagramFunctor D X).mapCone (limit.cone F)).π.app k).app j ≫
      (colimit.ι (F ⋙ J.diagramFunctor D X).flip j).app k ≫
        (colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k).hom
state_after: case e_a.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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ colimit.ι (J.diagram (F.obj k) X) j =
    (colimit.ι (F ⋙ J.diagramFunctor D X).flip j).app k ≫
      (colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k).hom

tactic: rw [← Iso.comp_inv_eq]
state_before: case e_a.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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ colimit.ι (J.diagram (F.obj k) X) j =
    (colimit.ι (F ⋙ J.diagramFunctor D X).flip j).app k ≫
      (colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k).hom
state_after: case e_a.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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ colimit.ι (J.diagram (F.obj k) X) j ≫ (colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k).inv =
    (colimit.ι (F ⋙ J.diagramFunctor D X).flip j).app k

tactic: erw [colimit.ι_desc]
state_before: case e_a.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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ colimit.ι (J.diagram (F.obj k) X) j ≫ (colimitObjIsoColimitCompEvaluation (F ⋙ J.diagramFunctor D X).flip k).inv =
    (colimit.ι (F ⋙ J.diagramFunctor D X).flip j).app k
state_after: case e_a.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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ (((evaluation K D).obj k).mapCocone (colimit.cocone (F ⋙ J.diagramFunctor D X).flip)).ι.app j =
    (colimit.ι (F ⋙ J.diagramFunctor D X).flip j).app k

tactic: rfl
state_before: case e_a.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 : J.Cover X), HasMultiequalizer (S.index P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : C
S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj { unop := X })
k : K
j : (J.Cover { unop := X }.unop)ᵒᵖ
⊢ (((evaluation K D).obj k).mapCocone (colimit.cocone (F ⋙ J.diagramFunctor D X).flip)).ι.app j =
    (colimit.ι (F ⋙ J.diagramFunctor D X).flip j).app k
state_after: no goals